linear_solver.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: ortools/linear_solver/linear_solver.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto
 
#include <limits>
#include <string>
 
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
 
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.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/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_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "ortools/util/optional_boolean.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE
 
// Internal implementation detail -- do not use these members.
struct TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[21]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
namespace operations_research {
class MPAbsConstraint;
struct MPAbsConstraintDefaultTypeInternal;
extern MPAbsConstraintDefaultTypeInternal _MPAbsConstraint_default_instance_;
class MPArrayConstraint;
struct MPArrayConstraintDefaultTypeInternal;
extern MPArrayConstraintDefaultTypeInternal _MPArrayConstraint_default_instance_;
class MPArrayWithConstantConstraint;
struct MPArrayWithConstantConstraintDefaultTypeInternal;
extern MPArrayWithConstantConstraintDefaultTypeInternal _MPArrayWithConstantConstraint_default_instance_;
class MPConstraintProto;
struct MPConstraintProtoDefaultTypeInternal;
extern MPConstraintProtoDefaultTypeInternal _MPConstraintProto_default_instance_;
class MPGeneralConstraintProto;
struct MPGeneralConstraintProtoDefaultTypeInternal;
extern MPGeneralConstraintProtoDefaultTypeInternal _MPGeneralConstraintProto_default_instance_;
class MPIndicatorConstraint;
struct MPIndicatorConstraintDefaultTypeInternal;
extern MPIndicatorConstraintDefaultTypeInternal _MPIndicatorConstraint_default_instance_;
class MPModelDeltaProto;
struct MPModelDeltaProtoDefaultTypeInternal;
extern MPModelDeltaProtoDefaultTypeInternal _MPModelDeltaProto_default_instance_;
class MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse;
struct MPModelDeltaProto_ConstraintOverridesEntry_DoNotUseDefaultTypeInternal;
extern MPModelDeltaProto_ConstraintOverridesEntry_DoNotUseDefaultTypeInternal _MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse_default_instance_;
class MPModelDeltaProto_VariableOverridesEntry_DoNotUse;
struct MPModelDeltaProto_VariableOverridesEntry_DoNotUseDefaultTypeInternal;
extern MPModelDeltaProto_VariableOverridesEntry_DoNotUseDefaultTypeInternal _MPModelDeltaProto_VariableOverridesEntry_DoNotUse_default_instance_;
class MPModelProto;
struct MPModelProtoDefaultTypeInternal;
extern MPModelProtoDefaultTypeInternal _MPModelProto_default_instance_;
class MPModelRequest;
struct MPModelRequestDefaultTypeInternal;
extern MPModelRequestDefaultTypeInternal _MPModelRequest_default_instance_;
class MPQuadraticConstraint;
struct MPQuadraticConstraintDefaultTypeInternal;
extern MPQuadraticConstraintDefaultTypeInternal _MPQuadraticConstraint_default_instance_;
class MPQuadraticObjective;
struct MPQuadraticObjectiveDefaultTypeInternal;
extern MPQuadraticObjectiveDefaultTypeInternal _MPQuadraticObjective_default_instance_;
class MPSolution;
struct MPSolutionDefaultTypeInternal;
extern MPSolutionDefaultTypeInternal _MPSolution_default_instance_;
class MPSolutionResponse;
struct MPSolutionResponseDefaultTypeInternal;
extern MPSolutionResponseDefaultTypeInternal _MPSolutionResponse_default_instance_;
class MPSolveInfo;
struct MPSolveInfoDefaultTypeInternal;
extern MPSolveInfoDefaultTypeInternal _MPSolveInfo_default_instance_;
class MPSolverCommonParameters;
struct MPSolverCommonParametersDefaultTypeInternal;
extern MPSolverCommonParametersDefaultTypeInternal _MPSolverCommonParameters_default_instance_;
class MPSosConstraint;
struct MPSosConstraintDefaultTypeInternal;
extern MPSosConstraintDefaultTypeInternal _MPSosConstraint_default_instance_;
class MPVariableProto;
struct MPVariableProtoDefaultTypeInternal;
extern MPVariableProtoDefaultTypeInternal _MPVariableProto_default_instance_;
class OptionalDouble;
struct OptionalDoubleDefaultTypeInternal;
extern OptionalDoubleDefaultTypeInternal _OptionalDouble_default_instance_;
class PartialVariableAssignment;
struct PartialVariableAssignmentDefaultTypeInternal;
extern PartialVariableAssignmentDefaultTypeInternal _PartialVariableAssignment_default_instance_;
}  // namespace operations_research
PROTOBUF_NAMESPACE_OPEN
template<> ::operations_research::MPAbsConstraint* Arena::CreateMaybeMessage<::operations_research::MPAbsConstraint>(Arena*);
template<> ::operations_research::MPArrayConstraint* Arena::CreateMaybeMessage<::operations_research::MPArrayConstraint>(Arena*);
template<> ::operations_research::MPArrayWithConstantConstraint* Arena::CreateMaybeMessage<::operations_research::MPArrayWithConstantConstraint>(Arena*);
template<> ::operations_research::MPConstraintProto* Arena::CreateMaybeMessage<::operations_research::MPConstraintProto>(Arena*);
template<> ::operations_research::MPGeneralConstraintProto* Arena::CreateMaybeMessage<::operations_research::MPGeneralConstraintProto>(Arena*);
template<> ::operations_research::MPIndicatorConstraint* Arena::CreateMaybeMessage<::operations_research::MPIndicatorConstraint>(Arena*);
template<> ::operations_research::MPModelDeltaProto* Arena::CreateMaybeMessage<::operations_research::MPModelDeltaProto>(Arena*);
template<> ::operations_research::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse* Arena::CreateMaybeMessage<::operations_research::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse>(Arena*);
template<> ::operations_research::MPModelDeltaProto_VariableOverridesEntry_DoNotUse* Arena::CreateMaybeMessage<::operations_research::MPModelDeltaProto_VariableOverridesEntry_DoNotUse>(Arena*);
template<> ::operations_research::MPModelProto* Arena::CreateMaybeMessage<::operations_research::MPModelProto>(Arena*);
template<> ::operations_research::MPModelRequest* Arena::CreateMaybeMessage<::operations_research::MPModelRequest>(Arena*);
template<> ::operations_research::MPQuadraticConstraint* Arena::CreateMaybeMessage<::operations_research::MPQuadraticConstraint>(Arena*);
template<> ::operations_research::MPQuadraticObjective* Arena::CreateMaybeMessage<::operations_research::MPQuadraticObjective>(Arena*);
template<> ::operations_research::MPSolution* Arena::CreateMaybeMessage<::operations_research::MPSolution>(Arena*);
template<> ::operations_research::MPSolutionResponse* Arena::CreateMaybeMessage<::operations_research::MPSolutionResponse>(Arena*);
template<> ::operations_research::MPSolveInfo* Arena::CreateMaybeMessage<::operations_research::MPSolveInfo>(Arena*);
template<> ::operations_research::MPSolverCommonParameters* Arena::CreateMaybeMessage<::operations_research::MPSolverCommonParameters>(Arena*);
template<> ::operations_research::MPSosConstraint* Arena::CreateMaybeMessage<::operations_research::MPSosConstraint>(Arena*);
template<> ::operations_research::MPVariableProto* Arena::CreateMaybeMessage<::operations_research::MPVariableProto>(Arena*);
template<> ::operations_research::OptionalDouble* Arena::CreateMaybeMessage<::operations_research::OptionalDouble>(Arena*);
template<> ::operations_research::PartialVariableAssignment* Arena::CreateMaybeMessage<::operations_research::PartialVariableAssignment>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace operations_research {
 
enum MPSosConstraint_Type : int {
  MPSosConstraint_Type_SOS1_DEFAULT = 0,
  MPSosConstraint_Type_SOS2 = 1
};
bool MPSosConstraint_Type_IsValid(int value);
constexpr MPSosConstraint_Type MPSosConstraint_Type_Type_MIN = MPSosConstraint_Type_SOS1_DEFAULT;
constexpr MPSosConstraint_Type MPSosConstraint_Type_Type_MAX = MPSosConstraint_Type_SOS2;
constexpr int MPSosConstraint_Type_Type_ARRAYSIZE = MPSosConstraint_Type_Type_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MPSosConstraint_Type_descriptor();
template<typename T>
inline const std::string& MPSosConstraint_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MPSosConstraint_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MPSosConstraint_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MPSosConstraint_Type_descriptor(), enum_t_value);
}
inline bool MPSosConstraint_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MPSosConstraint_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MPSosConstraint_Type>(
    MPSosConstraint_Type_descriptor(), name, value);
}
enum MPSolverCommonParameters_LPAlgorithmValues : int {
  MPSolverCommonParameters_LPAlgorithmValues_LP_ALGO_UNSPECIFIED = 0,
  MPSolverCommonParameters_LPAlgorithmValues_LP_ALGO_DUAL = 1,
  MPSolverCommonParameters_LPAlgorithmValues_LP_ALGO_PRIMAL = 2,
  MPSolverCommonParameters_LPAlgorithmValues_LP_ALGO_BARRIER = 3
};
bool MPSolverCommonParameters_LPAlgorithmValues_IsValid(int value);
constexpr MPSolverCommonParameters_LPAlgorithmValues MPSolverCommonParameters_LPAlgorithmValues_LPAlgorithmValues_MIN = MPSolverCommonParameters_LPAlgorithmValues_LP_ALGO_UNSPECIFIED;
constexpr MPSolverCommonParameters_LPAlgorithmValues MPSolverCommonParameters_LPAlgorithmValues_LPAlgorithmValues_MAX = MPSolverCommonParameters_LPAlgorithmValues_LP_ALGO_BARRIER;
constexpr int MPSolverCommonParameters_LPAlgorithmValues_LPAlgorithmValues_ARRAYSIZE = MPSolverCommonParameters_LPAlgorithmValues_LPAlgorithmValues_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MPSolverCommonParameters_LPAlgorithmValues_descriptor();
template<typename T>
inline const std::string& MPSolverCommonParameters_LPAlgorithmValues_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MPSolverCommonParameters_LPAlgorithmValues>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MPSolverCommonParameters_LPAlgorithmValues_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MPSolverCommonParameters_LPAlgorithmValues_descriptor(), enum_t_value);
}
inline bool MPSolverCommonParameters_LPAlgorithmValues_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MPSolverCommonParameters_LPAlgorithmValues* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MPSolverCommonParameters_LPAlgorithmValues>(
    MPSolverCommonParameters_LPAlgorithmValues_descriptor(), name, value);
}
enum MPModelRequest_SolverType : int {
  MPModelRequest_SolverType_GLOP_LINEAR_PROGRAMMING = 2,
  MPModelRequest_SolverType_CLP_LINEAR_PROGRAMMING = 0,
  MPModelRequest_SolverType_GLPK_LINEAR_PROGRAMMING = 1,
  MPModelRequest_SolverType_GUROBI_LINEAR_PROGRAMMING = 6,
  MPModelRequest_SolverType_XPRESS_LINEAR_PROGRAMMING = 101,
  MPModelRequest_SolverType_CPLEX_LINEAR_PROGRAMMING = 10,
  MPModelRequest_SolverType_SCIP_MIXED_INTEGER_PROGRAMMING = 3,
  MPModelRequest_SolverType_GLPK_MIXED_INTEGER_PROGRAMMING = 4,
  MPModelRequest_SolverType_CBC_MIXED_INTEGER_PROGRAMMING = 5,
  MPModelRequest_SolverType_GUROBI_MIXED_INTEGER_PROGRAMMING = 7,
  MPModelRequest_SolverType_XPRESS_MIXED_INTEGER_PROGRAMMING = 102,
  MPModelRequest_SolverType_CPLEX_MIXED_INTEGER_PROGRAMMING = 11,
  MPModelRequest_SolverType_BOP_INTEGER_PROGRAMMING = 12,
  MPModelRequest_SolverType_SAT_INTEGER_PROGRAMMING = 14,
  MPModelRequest_SolverType_KNAPSACK_MIXED_INTEGER_PROGRAMMING = 13
};
bool MPModelRequest_SolverType_IsValid(int value);
constexpr MPModelRequest_SolverType MPModelRequest_SolverType_SolverType_MIN = MPModelRequest_SolverType_CLP_LINEAR_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest_SolverType_SolverType_MAX = MPModelRequest_SolverType_XPRESS_MIXED_INTEGER_PROGRAMMING;
constexpr int MPModelRequest_SolverType_SolverType_ARRAYSIZE = MPModelRequest_SolverType_SolverType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MPModelRequest_SolverType_descriptor();
template<typename T>
inline const std::string& MPModelRequest_SolverType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MPModelRequest_SolverType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MPModelRequest_SolverType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MPModelRequest_SolverType_descriptor(), enum_t_value);
}
inline bool MPModelRequest_SolverType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MPModelRequest_SolverType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MPModelRequest_SolverType>(
    MPModelRequest_SolverType_descriptor(), name, value);
}
enum MPSolverResponseStatus : int {
  MPSOLVER_OPTIMAL = 0,
  MPSOLVER_FEASIBLE = 1,
  MPSOLVER_INFEASIBLE = 2,
  MPSOLVER_UNBOUNDED = 3,
  MPSOLVER_ABNORMAL = 4,
  MPSOLVER_NOT_SOLVED = 6,
  MPSOLVER_MODEL_IS_VALID = 97,
  MPSOLVER_CANCELLED_BY_USER = 98,
  MPSOLVER_UNKNOWN_STATUS = 99,
  MPSOLVER_MODEL_INVALID = 5,
  MPSOLVER_MODEL_INVALID_SOLUTION_HINT = 84,
  MPSOLVER_MODEL_INVALID_SOLVER_PARAMETERS = 85,
  MPSOLVER_SOLVER_TYPE_UNAVAILABLE = 7,
  MPSOLVER_INCOMPATIBLE_OPTIONS = 113
};
bool MPSolverResponseStatus_IsValid(int value);
constexpr MPSolverResponseStatus MPSolverResponseStatus_MIN = MPSOLVER_OPTIMAL;
constexpr MPSolverResponseStatus MPSolverResponseStatus_MAX = MPSOLVER_INCOMPATIBLE_OPTIONS;
constexpr int MPSolverResponseStatus_ARRAYSIZE = MPSolverResponseStatus_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MPSolverResponseStatus_descriptor();
template<typename T>
inline const std::string& MPSolverResponseStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MPSolverResponseStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MPSolverResponseStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MPSolverResponseStatus_descriptor(), enum_t_value);
}
inline bool MPSolverResponseStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MPSolverResponseStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MPSolverResponseStatus>(
    MPSolverResponseStatus_descriptor(), name, value);
}
// ===================================================================
 
class MPVariableProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPVariableProto) */ {
 public:
  inline MPVariableProto() : MPVariableProto(nullptr) {}
  ~MPVariableProto() override;
  explicit constexpr MPVariableProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPVariableProto(const MPVariableProto& from);
  MPVariableProto(MPVariableProto&& from) noexcept
    : MPVariableProto() {
    *this = ::std::move(from);
  }
 
  inline MPVariableProto& operator=(const MPVariableProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPVariableProto& operator=(MPVariableProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPVariableProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPVariableProto* internal_default_instance() {
    return reinterpret_cast<const MPVariableProto*>(
               &_MPVariableProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(MPVariableProto& a, MPVariableProto& b) {
    a.Swap(&b);
  }
  inline void Swap(MPVariableProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPVariableProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPVariableProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPVariableProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPVariableProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPVariableProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPVariableProto* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPVariableProto";
  }
  protected:
  explicit MPVariableProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kNameFieldNumber = 5,
    kObjectiveCoefficientFieldNumber = 3,
    kIsIntegerFieldNumber = 4,
    kBranchingPriorityFieldNumber = 6,
    kLowerBoundFieldNumber = 1,
    kUpperBoundFieldNumber = 2,
  };
  // optional string name = 5 [default = ""];
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:
 
  // optional double objective_coefficient = 3 [default = 0];
  bool has_objective_coefficient() const;
  private:
  bool _internal_has_objective_coefficient() const;
  public:
  void clear_objective_coefficient();
  double objective_coefficient() const;
  void set_objective_coefficient(double value);
  private:
  double _internal_objective_coefficient() const;
  void _internal_set_objective_coefficient(double value);
  public:
 
  // optional bool is_integer = 4 [default = false];
  bool has_is_integer() const;
  private:
  bool _internal_has_is_integer() const;
  public:
  void clear_is_integer();
  bool is_integer() const;
  void set_is_integer(bool value);
  private:
  bool _internal_is_integer() const;
  void _internal_set_is_integer(bool value);
  public:
 
  // optional int32 branching_priority = 6 [default = 0];
  bool has_branching_priority() const;
  private:
  bool _internal_has_branching_priority() const;
  public:
  void clear_branching_priority();
  int32_t branching_priority() const;
  void set_branching_priority(int32_t value);
  private:
  int32_t _internal_branching_priority() const;
  void _internal_set_branching_priority(int32_t value);
  public:
 
  // optional double lower_bound = 1 [default = -inf];
  bool has_lower_bound() const;
  private:
  bool _internal_has_lower_bound() const;
  public:
  void clear_lower_bound();
  double lower_bound() const;
  void set_lower_bound(double value);
  private:
  double _internal_lower_bound() const;
  void _internal_set_lower_bound(double value);
  public:
 
  // optional double upper_bound = 2 [default = inf];
  bool has_upper_bound() const;
  private:
  bool _internal_has_upper_bound() const;
  public:
  void clear_upper_bound();
  double upper_bound() const;
  void set_upper_bound(double value);
  private:
  double _internal_upper_bound() const;
  void _internal_set_upper_bound(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPVariableProto)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  double objective_coefficient_;
  bool is_integer_;
  int32_t branching_priority_;
  double lower_bound_;
  double upper_bound_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPConstraintProto) */ {
 public:
  inline MPConstraintProto() : MPConstraintProto(nullptr) {}
  ~MPConstraintProto() override;
  explicit constexpr MPConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPConstraintProto(const MPConstraintProto& from);
  MPConstraintProto(MPConstraintProto&& from) noexcept
    : MPConstraintProto() {
    *this = ::std::move(from);
  }
 
  inline MPConstraintProto& operator=(const MPConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPConstraintProto& operator=(MPConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPConstraintProto* internal_default_instance() {
    return reinterpret_cast<const MPConstraintProto*>(
               &_MPConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(MPConstraintProto& a, MPConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(MPConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPConstraintProto* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPConstraintProto";
  }
  protected:
  explicit MPConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kVarIndexFieldNumber = 6,
    kCoefficientFieldNumber = 7,
    kNameFieldNumber = 4,
    kIsLazyFieldNumber = 5,
    kLowerBoundFieldNumber = 2,
    kUpperBoundFieldNumber = 3,
  };
  // repeated int32 var_index = 6 [packed = true];
  int var_index_size() const;
  private:
  int _internal_var_index_size() const;
  public:
  void clear_var_index();
  private:
  int32_t _internal_var_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_var_index() const;
  void _internal_add_var_index(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_var_index();
  public:
  int32_t var_index(int index) const;
  void set_var_index(int index, int32_t value);
  void add_var_index(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      var_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_var_index();
 
  // repeated double coefficient = 7 [packed = true];
  int coefficient_size() const;
  private:
  int _internal_coefficient_size() const;
  public:
  void clear_coefficient();
  private:
  double _internal_coefficient(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_coefficient() const;
  void _internal_add_coefficient(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_coefficient();
  public:
  double coefficient(int index) const;
  void set_coefficient(int index, double value);
  void add_coefficient(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      coefficient() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_coefficient();
 
  // optional string name = 4 [default = ""];
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:
 
  // optional bool is_lazy = 5 [default = false];
  bool has_is_lazy() const;
  private:
  bool _internal_has_is_lazy() const;
  public:
  void clear_is_lazy();
  bool is_lazy() const;
  void set_is_lazy(bool value);
  private:
  bool _internal_is_lazy() const;
  void _internal_set_is_lazy(bool value);
  public:
 
  // optional double lower_bound = 2 [default = -inf];
  bool has_lower_bound() const;
  private:
  bool _internal_has_lower_bound() const;
  public:
  void clear_lower_bound();
  double lower_bound() const;
  void set_lower_bound(double value);
  private:
  double _internal_lower_bound() const;
  void _internal_set_lower_bound(double value);
  public:
 
  // optional double upper_bound = 3 [default = inf];
  bool has_upper_bound() const;
  private:
  bool _internal_has_upper_bound() const;
  public:
  void clear_upper_bound();
  double upper_bound() const;
  void set_upper_bound(double value);
  private:
  double _internal_upper_bound() const;
  void _internal_set_upper_bound(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPConstraintProto)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > var_index_;
  mutable std::atomic<int> _var_index_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > coefficient_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  bool is_lazy_;
  double lower_bound_;
  double upper_bound_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPGeneralConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPGeneralConstraintProto) */ {
 public:
  inline MPGeneralConstraintProto() : MPGeneralConstraintProto(nullptr) {}
  ~MPGeneralConstraintProto() override;
  explicit constexpr MPGeneralConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPGeneralConstraintProto(const MPGeneralConstraintProto& from);
  MPGeneralConstraintProto(MPGeneralConstraintProto&& from) noexcept
    : MPGeneralConstraintProto() {
    *this = ::std::move(from);
  }
 
  inline MPGeneralConstraintProto& operator=(const MPGeneralConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPGeneralConstraintProto& operator=(MPGeneralConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPGeneralConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  enum GeneralConstraintCase {
    kIndicatorConstraint = 2,
    kSosConstraint = 3,
    kQuadraticConstraint = 4,
    kAbsConstraint = 5,
    kAndConstraint = 6,
    kOrConstraint = 7,
    kMinConstraint = 8,
    kMaxConstraint = 9,
    GENERAL_CONSTRAINT_NOT_SET = 0,
  };
 
  static inline const MPGeneralConstraintProto* internal_default_instance() {
    return reinterpret_cast<const MPGeneralConstraintProto*>(
               &_MPGeneralConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  friend void swap(MPGeneralConstraintProto& a, MPGeneralConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(MPGeneralConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPGeneralConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPGeneralConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPGeneralConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPGeneralConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPGeneralConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPGeneralConstraintProto* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPGeneralConstraintProto";
  }
  protected:
  explicit MPGeneralConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kNameFieldNumber = 1,
    kIndicatorConstraintFieldNumber = 2,
    kSosConstraintFieldNumber = 3,
    kQuadraticConstraintFieldNumber = 4,
    kAbsConstraintFieldNumber = 5,
    kAndConstraintFieldNumber = 6,
    kOrConstraintFieldNumber = 7,
    kMinConstraintFieldNumber = 8,
    kMaxConstraintFieldNumber = 9,
  };
  // optional string name = 1 [default = ""];
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:
 
  // .operations_research.MPIndicatorConstraint indicator_constraint = 2;
  bool has_indicator_constraint() const;
  private:
  bool _internal_has_indicator_constraint() const;
  public:
  void clear_indicator_constraint();
  const ::operations_research::MPIndicatorConstraint& indicator_constraint() const;
  PROTOBUF_NODISCARD ::operations_research::MPIndicatorConstraint* release_indicator_constraint();
  ::operations_research::MPIndicatorConstraint* mutable_indicator_constraint();
  void set_allocated_indicator_constraint(::operations_research::MPIndicatorConstraint* indicator_constraint);
  private:
  const ::operations_research::MPIndicatorConstraint& _internal_indicator_constraint() const;
  ::operations_research::MPIndicatorConstraint* _internal_mutable_indicator_constraint();
  public:
  void unsafe_arena_set_allocated_indicator_constraint(
      ::operations_research::MPIndicatorConstraint* indicator_constraint);
  ::operations_research::MPIndicatorConstraint* unsafe_arena_release_indicator_constraint();
 
  // .operations_research.MPSosConstraint sos_constraint = 3;
  bool has_sos_constraint() const;
  private:
  bool _internal_has_sos_constraint() const;
  public:
  void clear_sos_constraint();
  const ::operations_research::MPSosConstraint& sos_constraint() const;
  PROTOBUF_NODISCARD ::operations_research::MPSosConstraint* release_sos_constraint();
  ::operations_research::MPSosConstraint* mutable_sos_constraint();
  void set_allocated_sos_constraint(::operations_research::MPSosConstraint* sos_constraint);
  private:
  const ::operations_research::MPSosConstraint& _internal_sos_constraint() const;
  ::operations_research::MPSosConstraint* _internal_mutable_sos_constraint();
  public:
  void unsafe_arena_set_allocated_sos_constraint(
      ::operations_research::MPSosConstraint* sos_constraint);
  ::operations_research::MPSosConstraint* unsafe_arena_release_sos_constraint();
 
  // .operations_research.MPQuadraticConstraint quadratic_constraint = 4;
  bool has_quadratic_constraint() const;
  private:
  bool _internal_has_quadratic_constraint() const;
  public:
  void clear_quadratic_constraint();
  const ::operations_research::MPQuadraticConstraint& quadratic_constraint() const;
  PROTOBUF_NODISCARD ::operations_research::MPQuadraticConstraint* release_quadratic_constraint();
  ::operations_research::MPQuadraticConstraint* mutable_quadratic_constraint();
  void set_allocated_quadratic_constraint(::operations_research::MPQuadraticConstraint* quadratic_constraint);
  private:
  const ::operations_research::MPQuadraticConstraint& _internal_quadratic_constraint() const;
  ::operations_research::MPQuadraticConstraint* _internal_mutable_quadratic_constraint();
  public:
  void unsafe_arena_set_allocated_quadratic_constraint(
      ::operations_research::MPQuadraticConstraint* quadratic_constraint);
  ::operations_research::MPQuadraticConstraint* unsafe_arena_release_quadratic_constraint();
 
  // .operations_research.MPAbsConstraint abs_constraint = 5;
  bool has_abs_constraint() const;
  private:
  bool _internal_has_abs_constraint() const;
  public:
  void clear_abs_constraint();
  const ::operations_research::MPAbsConstraint& abs_constraint() const;
  PROTOBUF_NODISCARD ::operations_research::MPAbsConstraint* release_abs_constraint();
  ::operations_research::MPAbsConstraint* mutable_abs_constraint();
  void set_allocated_abs_constraint(::operations_research::MPAbsConstraint* abs_constraint);
  private:
  const ::operations_research::MPAbsConstraint& _internal_abs_constraint() const;
  ::operations_research::MPAbsConstraint* _internal_mutable_abs_constraint();
  public:
  void unsafe_arena_set_allocated_abs_constraint(
      ::operations_research::MPAbsConstraint* abs_constraint);
  ::operations_research::MPAbsConstraint* unsafe_arena_release_abs_constraint();
 
  // .operations_research.MPArrayConstraint and_constraint = 6;
  bool has_and_constraint() const;
  private:
  bool _internal_has_and_constraint() const;
  public:
  void clear_and_constraint();
  const ::operations_research::MPArrayConstraint& and_constraint() const;
  PROTOBUF_NODISCARD ::operations_research::MPArrayConstraint* release_and_constraint();
  ::operations_research::MPArrayConstraint* mutable_and_constraint();
  void set_allocated_and_constraint(::operations_research::MPArrayConstraint* and_constraint);
  private:
  const ::operations_research::MPArrayConstraint& _internal_and_constraint() const;
  ::operations_research::MPArrayConstraint* _internal_mutable_and_constraint();
  public:
  void unsafe_arena_set_allocated_and_constraint(
      ::operations_research::MPArrayConstraint* and_constraint);
  ::operations_research::MPArrayConstraint* unsafe_arena_release_and_constraint();
 
  // .operations_research.MPArrayConstraint or_constraint = 7;
  bool has_or_constraint() const;
  private:
  bool _internal_has_or_constraint() const;
  public:
  void clear_or_constraint();
  const ::operations_research::MPArrayConstraint& or_constraint() const;
  PROTOBUF_NODISCARD ::operations_research::MPArrayConstraint* release_or_constraint();
  ::operations_research::MPArrayConstraint* mutable_or_constraint();
  void set_allocated_or_constraint(::operations_research::MPArrayConstraint* or_constraint);
  private:
  const ::operations_research::MPArrayConstraint& _internal_or_constraint() const;
  ::operations_research::MPArrayConstraint* _internal_mutable_or_constraint();
  public:
  void unsafe_arena_set_allocated_or_constraint(
      ::operations_research::MPArrayConstraint* or_constraint);
  ::operations_research::MPArrayConstraint* unsafe_arena_release_or_constraint();
 
  // .operations_research.MPArrayWithConstantConstraint min_constraint = 8;
  bool has_min_constraint() const;
  private:
  bool _internal_has_min_constraint() const;
  public:
  void clear_min_constraint();
  const ::operations_research::MPArrayWithConstantConstraint& min_constraint() const;
  PROTOBUF_NODISCARD ::operations_research::MPArrayWithConstantConstraint* release_min_constraint();
  ::operations_research::MPArrayWithConstantConstraint* mutable_min_constraint();
  void set_allocated_min_constraint(::operations_research::MPArrayWithConstantConstraint* min_constraint);
  private:
  const ::operations_research::MPArrayWithConstantConstraint& _internal_min_constraint() const;
  ::operations_research::MPArrayWithConstantConstraint* _internal_mutable_min_constraint();
  public:
  void unsafe_arena_set_allocated_min_constraint(
      ::operations_research::MPArrayWithConstantConstraint* min_constraint);
  ::operations_research::MPArrayWithConstantConstraint* unsafe_arena_release_min_constraint();
 
  // .operations_research.MPArrayWithConstantConstraint max_constraint = 9;
  bool has_max_constraint() const;
  private:
  bool _internal_has_max_constraint() const;
  public:
  void clear_max_constraint();
  const ::operations_research::MPArrayWithConstantConstraint& max_constraint() const;
  PROTOBUF_NODISCARD ::operations_research::MPArrayWithConstantConstraint* release_max_constraint();
  ::operations_research::MPArrayWithConstantConstraint* mutable_max_constraint();
  void set_allocated_max_constraint(::operations_research::MPArrayWithConstantConstraint* max_constraint);
  private:
  const ::operations_research::MPArrayWithConstantConstraint& _internal_max_constraint() const;
  ::operations_research::MPArrayWithConstantConstraint* _internal_mutable_max_constraint();
  public:
  void unsafe_arena_set_allocated_max_constraint(
      ::operations_research::MPArrayWithConstantConstraint* max_constraint);
  ::operations_research::MPArrayWithConstantConstraint* unsafe_arena_release_max_constraint();
 
  void clear_general_constraint();
  GeneralConstraintCase general_constraint_case() const;
  // @@protoc_insertion_point(class_scope:operations_research.MPGeneralConstraintProto)
 private:
  class _Internal;
  void set_has_indicator_constraint();
  void set_has_sos_constraint();
  void set_has_quadratic_constraint();
  void set_has_abs_constraint();
  void set_has_and_constraint();
  void set_has_or_constraint();
  void set_has_min_constraint();
  void set_has_max_constraint();
 
  inline bool has_general_constraint() const;
  inline void clear_has_general_constraint();
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  union GeneralConstraintUnion {
    constexpr GeneralConstraintUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::operations_research::MPIndicatorConstraint* indicator_constraint_;
    ::operations_research::MPSosConstraint* sos_constraint_;
    ::operations_research::MPQuadraticConstraint* quadratic_constraint_;
    ::operations_research::MPAbsConstraint* abs_constraint_;
    ::operations_research::MPArrayConstraint* and_constraint_;
    ::operations_research::MPArrayConstraint* or_constraint_;
    ::operations_research::MPArrayWithConstantConstraint* min_constraint_;
    ::operations_research::MPArrayWithConstantConstraint* max_constraint_;
  } general_constraint_;
  uint32_t _oneof_case_[1];
 
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPIndicatorConstraint final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPIndicatorConstraint) */ {
 public:
  inline MPIndicatorConstraint() : MPIndicatorConstraint(nullptr) {}
  ~MPIndicatorConstraint() override;
  explicit constexpr MPIndicatorConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPIndicatorConstraint(const MPIndicatorConstraint& from);
  MPIndicatorConstraint(MPIndicatorConstraint&& from) noexcept
    : MPIndicatorConstraint() {
    *this = ::std::move(from);
  }
 
  inline MPIndicatorConstraint& operator=(const MPIndicatorConstraint& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPIndicatorConstraint& operator=(MPIndicatorConstraint&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPIndicatorConstraint& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPIndicatorConstraint* internal_default_instance() {
    return reinterpret_cast<const MPIndicatorConstraint*>(
               &_MPIndicatorConstraint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  friend void swap(MPIndicatorConstraint& a, MPIndicatorConstraint& b) {
    a.Swap(&b);
  }
  inline void Swap(MPIndicatorConstraint* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPIndicatorConstraint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPIndicatorConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPIndicatorConstraint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPIndicatorConstraint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPIndicatorConstraint& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPIndicatorConstraint* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPIndicatorConstraint";
  }
  protected:
  explicit MPIndicatorConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kConstraintFieldNumber = 3,
    kVarIndexFieldNumber = 1,
    kVarValueFieldNumber = 2,
  };
  // optional .operations_research.MPConstraintProto constraint = 3;
  bool has_constraint() const;
  private:
  bool _internal_has_constraint() const;
  public:
  void clear_constraint();
  const ::operations_research::MPConstraintProto& constraint() const;
  PROTOBUF_NODISCARD ::operations_research::MPConstraintProto* release_constraint();
  ::operations_research::MPConstraintProto* mutable_constraint();
  void set_allocated_constraint(::operations_research::MPConstraintProto* constraint);
  private:
  const ::operations_research::MPConstraintProto& _internal_constraint() const;
  ::operations_research::MPConstraintProto* _internal_mutable_constraint();
  public:
  void unsafe_arena_set_allocated_constraint(
      ::operations_research::MPConstraintProto* constraint);
  ::operations_research::MPConstraintProto* unsafe_arena_release_constraint();
 
  // optional int32 var_index = 1;
  bool has_var_index() const;
  private:
  bool _internal_has_var_index() const;
  public:
  void clear_var_index();
  int32_t var_index() const;
  void set_var_index(int32_t value);
  private:
  int32_t _internal_var_index() const;
  void _internal_set_var_index(int32_t value);
  public:
 
  // optional int32 var_value = 2;
  bool has_var_value() const;
  private:
  bool _internal_has_var_value() const;
  public:
  void clear_var_value();
  int32_t var_value() const;
  void set_var_value(int32_t value);
  private:
  int32_t _internal_var_value() const;
  void _internal_set_var_value(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPIndicatorConstraint)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::operations_research::MPConstraintProto* constraint_;
  int32_t var_index_;
  int32_t var_value_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPSosConstraint final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPSosConstraint) */ {
 public:
  inline MPSosConstraint() : MPSosConstraint(nullptr) {}
  ~MPSosConstraint() override;
  explicit constexpr MPSosConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPSosConstraint(const MPSosConstraint& from);
  MPSosConstraint(MPSosConstraint&& from) noexcept
    : MPSosConstraint() {
    *this = ::std::move(from);
  }
 
  inline MPSosConstraint& operator=(const MPSosConstraint& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPSosConstraint& operator=(MPSosConstraint&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPSosConstraint& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPSosConstraint* internal_default_instance() {
    return reinterpret_cast<const MPSosConstraint*>(
               &_MPSosConstraint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  friend void swap(MPSosConstraint& a, MPSosConstraint& b) {
    a.Swap(&b);
  }
  inline void Swap(MPSosConstraint* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPSosConstraint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPSosConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPSosConstraint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPSosConstraint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPSosConstraint& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPSosConstraint* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPSosConstraint";
  }
  protected:
  explicit MPSosConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef MPSosConstraint_Type Type;
  static constexpr Type SOS1_DEFAULT =
    MPSosConstraint_Type_SOS1_DEFAULT;
  static constexpr Type SOS2 =
    MPSosConstraint_Type_SOS2;
  static inline bool Type_IsValid(int value) {
    return MPSosConstraint_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    MPSosConstraint_Type_Type_MIN;
  static constexpr Type Type_MAX =
    MPSosConstraint_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    MPSosConstraint_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return MPSosConstraint_Type_descriptor();
  }
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return MPSosConstraint_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return MPSosConstraint_Type_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kVarIndexFieldNumber = 2,
    kWeightFieldNumber = 3,
    kTypeFieldNumber = 1,
  };
  // repeated int32 var_index = 2;
  int var_index_size() const;
  private:
  int _internal_var_index_size() const;
  public:
  void clear_var_index();
  private:
  int32_t _internal_var_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_var_index() const;
  void _internal_add_var_index(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_var_index();
  public:
  int32_t var_index(int index) const;
  void set_var_index(int index, int32_t value);
  void add_var_index(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      var_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_var_index();
 
  // repeated double weight = 3;
  int weight_size() const;
  private:
  int _internal_weight_size() const;
  public:
  void clear_weight();
  private:
  double _internal_weight(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_weight() const;
  void _internal_add_weight(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_weight();
  public:
  double weight(int index) const;
  void set_weight(int index, double value);
  void add_weight(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      weight() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_weight();
 
  // optional .operations_research.MPSosConstraint.Type type = 1 [default = SOS1_DEFAULT];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::operations_research::MPSosConstraint_Type type() const;
  void set_type(::operations_research::MPSosConstraint_Type value);
  private:
  ::operations_research::MPSosConstraint_Type _internal_type() const;
  void _internal_set_type(::operations_research::MPSosConstraint_Type value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPSosConstraint)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > var_index_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > weight_;
  int type_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPQuadraticConstraint final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPQuadraticConstraint) */ {
 public:
  inline MPQuadraticConstraint() : MPQuadraticConstraint(nullptr) {}
  ~MPQuadraticConstraint() override;
  explicit constexpr MPQuadraticConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPQuadraticConstraint(const MPQuadraticConstraint& from);
  MPQuadraticConstraint(MPQuadraticConstraint&& from) noexcept
    : MPQuadraticConstraint() {
    *this = ::std::move(from);
  }
 
  inline MPQuadraticConstraint& operator=(const MPQuadraticConstraint& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPQuadraticConstraint& operator=(MPQuadraticConstraint&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPQuadraticConstraint& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPQuadraticConstraint* internal_default_instance() {
    return reinterpret_cast<const MPQuadraticConstraint*>(
               &_MPQuadraticConstraint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  friend void swap(MPQuadraticConstraint& a, MPQuadraticConstraint& b) {
    a.Swap(&b);
  }
  inline void Swap(MPQuadraticConstraint* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPQuadraticConstraint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPQuadraticConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPQuadraticConstraint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPQuadraticConstraint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPQuadraticConstraint& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPQuadraticConstraint* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPQuadraticConstraint";
  }
  protected:
  explicit MPQuadraticConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kVarIndexFieldNumber = 1,
    kCoefficientFieldNumber = 2,
    kQvar1IndexFieldNumber = 3,
    kQvar2IndexFieldNumber = 4,
    kQcoefficientFieldNumber = 5,
    kLowerBoundFieldNumber = 6,
    kUpperBoundFieldNumber = 7,
  };
  // repeated int32 var_index = 1;
  int var_index_size() const;
  private:
  int _internal_var_index_size() const;
  public:
  void clear_var_index();
  private:
  int32_t _internal_var_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_var_index() const;
  void _internal_add_var_index(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_var_index();
  public:
  int32_t var_index(int index) const;
  void set_var_index(int index, int32_t value);
  void add_var_index(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      var_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_var_index();
 
  // repeated double coefficient = 2;
  int coefficient_size() const;
  private:
  int _internal_coefficient_size() const;
  public:
  void clear_coefficient();
  private:
  double _internal_coefficient(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_coefficient() const;
  void _internal_add_coefficient(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_coefficient();
  public:
  double coefficient(int index) const;
  void set_coefficient(int index, double value);
  void add_coefficient(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      coefficient() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_coefficient();
 
  // repeated int32 qvar1_index = 3;
  int qvar1_index_size() const;
  private:
  int _internal_qvar1_index_size() const;
  public:
  void clear_qvar1_index();
  private:
  int32_t _internal_qvar1_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_qvar1_index() const;
  void _internal_add_qvar1_index(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_qvar1_index();
  public:
  int32_t qvar1_index(int index) const;
  void set_qvar1_index(int index, int32_t value);
  void add_qvar1_index(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      qvar1_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_qvar1_index();
 
  // repeated int32 qvar2_index = 4;
  int qvar2_index_size() const;
  private:
  int _internal_qvar2_index_size() const;
  public:
  void clear_qvar2_index();
  private:
  int32_t _internal_qvar2_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_qvar2_index() const;
  void _internal_add_qvar2_index(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_qvar2_index();
  public:
  int32_t qvar2_index(int index) const;
  void set_qvar2_index(int index, int32_t value);
  void add_qvar2_index(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      qvar2_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_qvar2_index();
 
  // repeated double qcoefficient = 5;
  int qcoefficient_size() const;
  private:
  int _internal_qcoefficient_size() const;
  public:
  void clear_qcoefficient();
  private:
  double _internal_qcoefficient(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_qcoefficient() const;
  void _internal_add_qcoefficient(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_qcoefficient();
  public:
  double qcoefficient(int index) const;
  void set_qcoefficient(int index, double value);
  void add_qcoefficient(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      qcoefficient() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_qcoefficient();
 
  // optional double lower_bound = 6 [default = -inf];
  bool has_lower_bound() const;
  private:
  bool _internal_has_lower_bound() const;
  public:
  void clear_lower_bound();
  double lower_bound() const;
  void set_lower_bound(double value);
  private:
  double _internal_lower_bound() const;
  void _internal_set_lower_bound(double value);
  public:
 
  // optional double upper_bound = 7 [default = inf];
  bool has_upper_bound() const;
  private:
  bool _internal_has_upper_bound() const;
  public:
  void clear_upper_bound();
  double upper_bound() const;
  void set_upper_bound(double value);
  private:
  double _internal_upper_bound() const;
  void _internal_set_upper_bound(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPQuadraticConstraint)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > var_index_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > coefficient_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > qvar1_index_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > qvar2_index_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > qcoefficient_;
  double lower_bound_;
  double upper_bound_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPAbsConstraint final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPAbsConstraint) */ {
 public:
  inline MPAbsConstraint() : MPAbsConstraint(nullptr) {}
  ~MPAbsConstraint() override;
  explicit constexpr MPAbsConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPAbsConstraint(const MPAbsConstraint& from);
  MPAbsConstraint(MPAbsConstraint&& from) noexcept
    : MPAbsConstraint() {
    *this = ::std::move(from);
  }
 
  inline MPAbsConstraint& operator=(const MPAbsConstraint& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPAbsConstraint& operator=(MPAbsConstraint&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPAbsConstraint& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPAbsConstraint* internal_default_instance() {
    return reinterpret_cast<const MPAbsConstraint*>(
               &_MPAbsConstraint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  friend void swap(MPAbsConstraint& a, MPAbsConstraint& b) {
    a.Swap(&b);
  }
  inline void Swap(MPAbsConstraint* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPAbsConstraint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPAbsConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPAbsConstraint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPAbsConstraint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPAbsConstraint& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPAbsConstraint* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPAbsConstraint";
  }
  protected:
  explicit MPAbsConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kVarIndexFieldNumber = 1,
    kResultantVarIndexFieldNumber = 2,
  };
  // optional int32 var_index = 1;
  bool has_var_index() const;
  private:
  bool _internal_has_var_index() const;
  public:
  void clear_var_index();
  int32_t var_index() const;
  void set_var_index(int32_t value);
  private:
  int32_t _internal_var_index() const;
  void _internal_set_var_index(int32_t value);
  public:
 
  // optional int32 resultant_var_index = 2;
  bool has_resultant_var_index() const;
  private:
  bool _internal_has_resultant_var_index() const;
  public:
  void clear_resultant_var_index();
  int32_t resultant_var_index() const;
  void set_resultant_var_index(int32_t value);
  private:
  int32_t _internal_resultant_var_index() const;
  void _internal_set_resultant_var_index(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPAbsConstraint)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  int32_t var_index_;
  int32_t resultant_var_index_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPArrayConstraint final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPArrayConstraint) */ {
 public:
  inline MPArrayConstraint() : MPArrayConstraint(nullptr) {}
  ~MPArrayConstraint() override;
  explicit constexpr MPArrayConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPArrayConstraint(const MPArrayConstraint& from);
  MPArrayConstraint(MPArrayConstraint&& from) noexcept
    : MPArrayConstraint() {
    *this = ::std::move(from);
  }
 
  inline MPArrayConstraint& operator=(const MPArrayConstraint& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPArrayConstraint& operator=(MPArrayConstraint&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPArrayConstraint& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPArrayConstraint* internal_default_instance() {
    return reinterpret_cast<const MPArrayConstraint*>(
               &_MPArrayConstraint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;
 
  friend void swap(MPArrayConstraint& a, MPArrayConstraint& b) {
    a.Swap(&b);
  }
  inline void Swap(MPArrayConstraint* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPArrayConstraint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPArrayConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPArrayConstraint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPArrayConstraint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPArrayConstraint& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPArrayConstraint* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPArrayConstraint";
  }
  protected:
  explicit MPArrayConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kVarIndexFieldNumber = 1,
    kResultantVarIndexFieldNumber = 2,
  };
  // repeated int32 var_index = 1;
  int var_index_size() const;
  private:
  int _internal_var_index_size() const;
  public:
  void clear_var_index();
  private:
  int32_t _internal_var_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_var_index() const;
  void _internal_add_var_index(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_var_index();
  public:
  int32_t var_index(int index) const;
  void set_var_index(int index, int32_t value);
  void add_var_index(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      var_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_var_index();
 
  // optional int32 resultant_var_index = 2;
  bool has_resultant_var_index() const;
  private:
  bool _internal_has_resultant_var_index() const;
  public:
  void clear_resultant_var_index();
  int32_t resultant_var_index() const;
  void set_resultant_var_index(int32_t value);
  private:
  int32_t _internal_resultant_var_index() const;
  void _internal_set_resultant_var_index(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPArrayConstraint)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > var_index_;
  int32_t resultant_var_index_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPArrayWithConstantConstraint final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPArrayWithConstantConstraint) */ {
 public:
  inline MPArrayWithConstantConstraint() : MPArrayWithConstantConstraint(nullptr) {}
  ~MPArrayWithConstantConstraint() override;
  explicit constexpr MPArrayWithConstantConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPArrayWithConstantConstraint(const MPArrayWithConstantConstraint& from);
  MPArrayWithConstantConstraint(MPArrayWithConstantConstraint&& from) noexcept
    : MPArrayWithConstantConstraint() {
    *this = ::std::move(from);
  }
 
  inline MPArrayWithConstantConstraint& operator=(const MPArrayWithConstantConstraint& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPArrayWithConstantConstraint& operator=(MPArrayWithConstantConstraint&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPArrayWithConstantConstraint& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPArrayWithConstantConstraint* internal_default_instance() {
    return reinterpret_cast<const MPArrayWithConstantConstraint*>(
               &_MPArrayWithConstantConstraint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;
 
  friend void swap(MPArrayWithConstantConstraint& a, MPArrayWithConstantConstraint& b) {
    a.Swap(&b);
  }
  inline void Swap(MPArrayWithConstantConstraint* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPArrayWithConstantConstraint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPArrayWithConstantConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPArrayWithConstantConstraint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPArrayWithConstantConstraint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPArrayWithConstantConstraint& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPArrayWithConstantConstraint* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPArrayWithConstantConstraint";
  }
  protected:
  explicit MPArrayWithConstantConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kVarIndexFieldNumber = 1,
    kConstantFieldNumber = 2,
    kResultantVarIndexFieldNumber = 3,
  };
  // repeated int32 var_index = 1;
  int var_index_size() const;
  private:
  int _internal_var_index_size() const;
  public:
  void clear_var_index();
  private:
  int32_t _internal_var_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_var_index() const;
  void _internal_add_var_index(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_var_index();
  public:
  int32_t var_index(int index) const;
  void set_var_index(int index, int32_t value);
  void add_var_index(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      var_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_var_index();
 
  // optional double constant = 2;
  bool has_constant() const;
  private:
  bool _internal_has_constant() const;
  public:
  void clear_constant();
  double constant() const;
  void set_constant(double value);
  private:
  double _internal_constant() const;
  void _internal_set_constant(double value);
  public:
 
  // optional int32 resultant_var_index = 3;
  bool has_resultant_var_index() const;
  private:
  bool _internal_has_resultant_var_index() const;
  public:
  void clear_resultant_var_index();
  int32_t resultant_var_index() const;
  void set_resultant_var_index(int32_t value);
  private:
  int32_t _internal_resultant_var_index() const;
  void _internal_set_resultant_var_index(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPArrayWithConstantConstraint)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > var_index_;
  double constant_;
  int32_t resultant_var_index_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPQuadraticObjective final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPQuadraticObjective) */ {
 public:
  inline MPQuadraticObjective() : MPQuadraticObjective(nullptr) {}
  ~MPQuadraticObjective() override;
  explicit constexpr MPQuadraticObjective(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPQuadraticObjective(const MPQuadraticObjective& from);
  MPQuadraticObjective(MPQuadraticObjective&& from) noexcept
    : MPQuadraticObjective() {
    *this = ::std::move(from);
  }
 
  inline MPQuadraticObjective& operator=(const MPQuadraticObjective& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPQuadraticObjective& operator=(MPQuadraticObjective&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPQuadraticObjective& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPQuadraticObjective* internal_default_instance() {
    return reinterpret_cast<const MPQuadraticObjective*>(
               &_MPQuadraticObjective_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;
 
  friend void swap(MPQuadraticObjective& a, MPQuadraticObjective& b) {
    a.Swap(&b);
  }
  inline void Swap(MPQuadraticObjective* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPQuadraticObjective* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPQuadraticObjective* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPQuadraticObjective>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPQuadraticObjective& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPQuadraticObjective& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPQuadraticObjective* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPQuadraticObjective";
  }
  protected:
  explicit MPQuadraticObjective(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kQvar1IndexFieldNumber = 1,
    kQvar2IndexFieldNumber = 2,
    kCoefficientFieldNumber = 3,
  };
  // repeated int32 qvar1_index = 1;
  int qvar1_index_size() const;
  private:
  int _internal_qvar1_index_size() const;
  public:
  void clear_qvar1_index();
  private:
  int32_t _internal_qvar1_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_qvar1_index() const;
  void _internal_add_qvar1_index(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_qvar1_index();
  public:
  int32_t qvar1_index(int index) const;
  void set_qvar1_index(int index, int32_t value);
  void add_qvar1_index(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      qvar1_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_qvar1_index();
 
  // repeated int32 qvar2_index = 2;
  int qvar2_index_size() const;
  private:
  int _internal_qvar2_index_size() const;
  public:
  void clear_qvar2_index();
  private:
  int32_t _internal_qvar2_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_qvar2_index() const;
  void _internal_add_qvar2_index(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_qvar2_index();
  public:
  int32_t qvar2_index(int index) const;
  void set_qvar2_index(int index, int32_t value);
  void add_qvar2_index(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      qvar2_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_qvar2_index();
 
  // repeated double coefficient = 3;
  int coefficient_size() const;
  private:
  int _internal_coefficient_size() const;
  public:
  void clear_coefficient();
  private:
  double _internal_coefficient(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_coefficient() const;
  void _internal_add_coefficient(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_coefficient();
  public:
  double coefficient(int index) const;
  void set_coefficient(int index, double value);
  void add_coefficient(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      coefficient() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_coefficient();
 
  // @@protoc_insertion_point(class_scope:operations_research.MPQuadraticObjective)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > qvar1_index_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > qvar2_index_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > coefficient_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class PartialVariableAssignment final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.PartialVariableAssignment) */ {
 public:
  inline PartialVariableAssignment() : PartialVariableAssignment(nullptr) {}
  ~PartialVariableAssignment() override;
  explicit constexpr PartialVariableAssignment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  PartialVariableAssignment(const PartialVariableAssignment& from);
  PartialVariableAssignment(PartialVariableAssignment&& from) noexcept
    : PartialVariableAssignment() {
    *this = ::std::move(from);
  }
 
  inline PartialVariableAssignment& operator=(const PartialVariableAssignment& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartialVariableAssignment& operator=(PartialVariableAssignment&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PartialVariableAssignment& default_instance() {
    return *internal_default_instance();
  }
  static inline const PartialVariableAssignment* internal_default_instance() {
    return reinterpret_cast<const PartialVariableAssignment*>(
               &_PartialVariableAssignment_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;
 
  friend void swap(PartialVariableAssignment& a, PartialVariableAssignment& b) {
    a.Swap(&b);
  }
  inline void Swap(PartialVariableAssignment* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartialVariableAssignment* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  PartialVariableAssignment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PartialVariableAssignment>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PartialVariableAssignment& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PartialVariableAssignment& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartialVariableAssignment* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.PartialVariableAssignment";
  }
  protected:
  explicit PartialVariableAssignment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kVarIndexFieldNumber = 1,
    kVarValueFieldNumber = 2,
  };
  // repeated int32 var_index = 1 [packed = true];
  int var_index_size() const;
  private:
  int _internal_var_index_size() const;
  public:
  void clear_var_index();
  private:
  int32_t _internal_var_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_var_index() const;
  void _internal_add_var_index(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_var_index();
  public:
  int32_t var_index(int index) const;
  void set_var_index(int index, int32_t value);
  void add_var_index(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      var_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_var_index();
 
  // repeated double var_value = 2 [packed = true];
  int var_value_size() const;
  private:
  int _internal_var_value_size() const;
  public:
  void clear_var_value();
  private:
  double _internal_var_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_var_value() const;
  void _internal_add_var_value(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_var_value();
  public:
  double var_value(int index) const;
  void set_var_value(int index, double value);
  void add_var_value(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      var_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_var_value();
 
  // @@protoc_insertion_point(class_scope:operations_research.PartialVariableAssignment)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > var_index_;
  mutable std::atomic<int> _var_index_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > var_value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPModelProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPModelProto) */ {
 public:
  inline MPModelProto() : MPModelProto(nullptr) {}
  ~MPModelProto() override;
  explicit constexpr MPModelProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPModelProto(const MPModelProto& from);
  MPModelProto(MPModelProto&& from) noexcept
    : MPModelProto() {
    *this = ::std::move(from);
  }
 
  inline MPModelProto& operator=(const MPModelProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPModelProto& operator=(MPModelProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPModelProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPModelProto* internal_default_instance() {
    return reinterpret_cast<const MPModelProto*>(
               &_MPModelProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;
 
  friend void swap(MPModelProto& a, MPModelProto& b) {
    a.Swap(&b);
  }
  inline void Swap(MPModelProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPModelProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPModelProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPModelProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPModelProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPModelProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPModelProto* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPModelProto";
  }
  protected:
  explicit MPModelProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kVariableFieldNumber = 3,
    kConstraintFieldNumber = 4,
    kGeneralConstraintFieldNumber = 7,
    kNameFieldNumber = 5,
    kSolutionHintFieldNumber = 6,
    kQuadraticObjectiveFieldNumber = 8,
    kObjectiveOffsetFieldNumber = 2,
    kMaximizeFieldNumber = 1,
  };
  // repeated .operations_research.MPVariableProto variable = 3;
  int variable_size() const;
  private:
  int _internal_variable_size() const;
  public:
  void clear_variable();
  ::operations_research::MPVariableProto* mutable_variable(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPVariableProto >*
      mutable_variable();
  private:
  const ::operations_research::MPVariableProto& _internal_variable(int index) const;
  ::operations_research::MPVariableProto* _internal_add_variable();
  public:
  const ::operations_research::MPVariableProto& variable(int index) const;
  ::operations_research::MPVariableProto* add_variable();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPVariableProto >&
      variable() const;
 
  // repeated .operations_research.MPConstraintProto constraint = 4;
  int constraint_size() const;
  private:
  int _internal_constraint_size() const;
  public:
  void clear_constraint();
  ::operations_research::MPConstraintProto* mutable_constraint(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPConstraintProto >*
      mutable_constraint();
  private:
  const ::operations_research::MPConstraintProto& _internal_constraint(int index) const;
  ::operations_research::MPConstraintProto* _internal_add_constraint();
  public:
  const ::operations_research::MPConstraintProto& constraint(int index) const;
  ::operations_research::MPConstraintProto* add_constraint();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPConstraintProto >&
      constraint() const;
 
  // repeated .operations_research.MPGeneralConstraintProto general_constraint = 7;
  int general_constraint_size() const;
  private:
  int _internal_general_constraint_size() const;
  public:
  void clear_general_constraint();
  ::operations_research::MPGeneralConstraintProto* mutable_general_constraint(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPGeneralConstraintProto >*
      mutable_general_constraint();
  private:
  const ::operations_research::MPGeneralConstraintProto& _internal_general_constraint(int index) const;
  ::operations_research::MPGeneralConstraintProto* _internal_add_general_constraint();
  public:
  const ::operations_research::MPGeneralConstraintProto& general_constraint(int index) const;
  ::operations_research::MPGeneralConstraintProto* add_general_constraint();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPGeneralConstraintProto >&
      general_constraint() const;
 
  // optional string name = 5 [default = ""];
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:
 
  // optional .operations_research.PartialVariableAssignment solution_hint = 6;
  bool has_solution_hint() const;
  private:
  bool _internal_has_solution_hint() const;
  public:
  void clear_solution_hint();
  const ::operations_research::PartialVariableAssignment& solution_hint() const;
  PROTOBUF_NODISCARD ::operations_research::PartialVariableAssignment* release_solution_hint();
  ::operations_research::PartialVariableAssignment* mutable_solution_hint();
  void set_allocated_solution_hint(::operations_research::PartialVariableAssignment* solution_hint);
  private:
  const ::operations_research::PartialVariableAssignment& _internal_solution_hint() const;
  ::operations_research::PartialVariableAssignment* _internal_mutable_solution_hint();
  public:
  void unsafe_arena_set_allocated_solution_hint(
      ::operations_research::PartialVariableAssignment* solution_hint);
  ::operations_research::PartialVariableAssignment* unsafe_arena_release_solution_hint();
 
  // optional .operations_research.MPQuadraticObjective quadratic_objective = 8;
  bool has_quadratic_objective() const;
  private:
  bool _internal_has_quadratic_objective() const;
  public:
  void clear_quadratic_objective();
  const ::operations_research::MPQuadraticObjective& quadratic_objective() const;
  PROTOBUF_NODISCARD ::operations_research::MPQuadraticObjective* release_quadratic_objective();
  ::operations_research::MPQuadraticObjective* mutable_quadratic_objective();
  void set_allocated_quadratic_objective(::operations_research::MPQuadraticObjective* quadratic_objective);
  private:
  const ::operations_research::MPQuadraticObjective& _internal_quadratic_objective() const;
  ::operations_research::MPQuadraticObjective* _internal_mutable_quadratic_objective();
  public:
  void unsafe_arena_set_allocated_quadratic_objective(
      ::operations_research::MPQuadraticObjective* quadratic_objective);
  ::operations_research::MPQuadraticObjective* unsafe_arena_release_quadratic_objective();
 
  // optional double objective_offset = 2 [default = 0];
  bool has_objective_offset() const;
  private:
  bool _internal_has_objective_offset() const;
  public:
  void clear_objective_offset();
  double objective_offset() const;
  void set_objective_offset(double value);
  private:
  double _internal_objective_offset() const;
  void _internal_set_objective_offset(double value);
  public:
 
  // optional bool maximize = 1 [default = false];
  bool has_maximize() const;
  private:
  bool _internal_has_maximize() const;
  public:
  void clear_maximize();
  bool maximize() const;
  void set_maximize(bool value);
  private:
  bool _internal_maximize() const;
  void _internal_set_maximize(bool value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPModelProto)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPVariableProto > variable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPConstraintProto > constraint_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPGeneralConstraintProto > general_constraint_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::operations_research::PartialVariableAssignment* solution_hint_;
  ::operations_research::MPQuadraticObjective* quadratic_objective_;
  double objective_offset_;
  bool maximize_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class OptionalDouble final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.OptionalDouble) */ {
 public:
  inline OptionalDouble() : OptionalDouble(nullptr) {}
  ~OptionalDouble() override;
  explicit constexpr OptionalDouble(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  OptionalDouble(const OptionalDouble& from);
  OptionalDouble(OptionalDouble&& from) noexcept
    : OptionalDouble() {
    *this = ::std::move(from);
  }
 
  inline OptionalDouble& operator=(const OptionalDouble& from) {
    CopyFrom(from);
    return *this;
  }
  inline OptionalDouble& operator=(OptionalDouble&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OptionalDouble& default_instance() {
    return *internal_default_instance();
  }
  static inline const OptionalDouble* internal_default_instance() {
    return reinterpret_cast<const OptionalDouble*>(
               &_OptionalDouble_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;
 
  friend void swap(OptionalDouble& a, OptionalDouble& b) {
    a.Swap(&b);
  }
  inline void Swap(OptionalDouble* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OptionalDouble* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  OptionalDouble* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OptionalDouble>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const OptionalDouble& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const OptionalDouble& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OptionalDouble* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.OptionalDouble";
  }
  protected:
  explicit OptionalDouble(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kValueFieldNumber = 1,
  };
  // optional double value = 1;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  double value() const;
  void set_value(double value);
  private:
  double _internal_value() const;
  void _internal_set_value(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.OptionalDouble)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  double value_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPSolverCommonParameters final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPSolverCommonParameters) */ {
 public:
  inline MPSolverCommonParameters() : MPSolverCommonParameters(nullptr) {}
  ~MPSolverCommonParameters() override;
  explicit constexpr MPSolverCommonParameters(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPSolverCommonParameters(const MPSolverCommonParameters& from);
  MPSolverCommonParameters(MPSolverCommonParameters&& from) noexcept
    : MPSolverCommonParameters() {
    *this = ::std::move(from);
  }
 
  inline MPSolverCommonParameters& operator=(const MPSolverCommonParameters& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPSolverCommonParameters& operator=(MPSolverCommonParameters&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPSolverCommonParameters& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPSolverCommonParameters* internal_default_instance() {
    return reinterpret_cast<const MPSolverCommonParameters*>(
               &_MPSolverCommonParameters_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;
 
  friend void swap(MPSolverCommonParameters& a, MPSolverCommonParameters& b) {
    a.Swap(&b);
  }
  inline void Swap(MPSolverCommonParameters* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPSolverCommonParameters* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPSolverCommonParameters* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPSolverCommonParameters>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPSolverCommonParameters& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPSolverCommonParameters& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPSolverCommonParameters* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPSolverCommonParameters";
  }
  protected:
  explicit MPSolverCommonParameters(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef MPSolverCommonParameters_LPAlgorithmValues LPAlgorithmValues;
  static constexpr LPAlgorithmValues LP_ALGO_UNSPECIFIED =
    MPSolverCommonParameters_LPAlgorithmValues_LP_ALGO_UNSPECIFIED;
  static constexpr LPAlgorithmValues LP_ALGO_DUAL =
    MPSolverCommonParameters_LPAlgorithmValues_LP_ALGO_DUAL;
  static constexpr LPAlgorithmValues LP_ALGO_PRIMAL =
    MPSolverCommonParameters_LPAlgorithmValues_LP_ALGO_PRIMAL;
  static constexpr LPAlgorithmValues LP_ALGO_BARRIER =
    MPSolverCommonParameters_LPAlgorithmValues_LP_ALGO_BARRIER;
  static inline bool LPAlgorithmValues_IsValid(int value) {
    return MPSolverCommonParameters_LPAlgorithmValues_IsValid(value);
  }
  static constexpr LPAlgorithmValues LPAlgorithmValues_MIN =
    MPSolverCommonParameters_LPAlgorithmValues_LPAlgorithmValues_MIN;
  static constexpr LPAlgorithmValues LPAlgorithmValues_MAX =
    MPSolverCommonParameters_LPAlgorithmValues_LPAlgorithmValues_MAX;
  static constexpr int LPAlgorithmValues_ARRAYSIZE =
    MPSolverCommonParameters_LPAlgorithmValues_LPAlgorithmValues_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  LPAlgorithmValues_descriptor() {
    return MPSolverCommonParameters_LPAlgorithmValues_descriptor();
  }
  template<typename T>
  static inline const std::string& LPAlgorithmValues_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LPAlgorithmValues>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LPAlgorithmValues_Name.");
    return MPSolverCommonParameters_LPAlgorithmValues_Name(enum_t_value);
  }
  static inline bool LPAlgorithmValues_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      LPAlgorithmValues* value) {
    return MPSolverCommonParameters_LPAlgorithmValues_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kRelativeMipGapFieldNumber = 1,
    kPrimalToleranceFieldNumber = 2,
    kDualToleranceFieldNumber = 3,
    kLpAlgorithmFieldNumber = 4,
    kPresolveFieldNumber = 5,
    kScalingFieldNumber = 7,
  };
  // optional .operations_research.OptionalDouble relative_mip_gap = 1;
  bool has_relative_mip_gap() const;
  private:
  bool _internal_has_relative_mip_gap() const;
  public:
  void clear_relative_mip_gap();
  const ::operations_research::OptionalDouble& relative_mip_gap() const;
  PROTOBUF_NODISCARD ::operations_research::OptionalDouble* release_relative_mip_gap();
  ::operations_research::OptionalDouble* mutable_relative_mip_gap();
  void set_allocated_relative_mip_gap(::operations_research::OptionalDouble* relative_mip_gap);
  private:
  const ::operations_research::OptionalDouble& _internal_relative_mip_gap() const;
  ::operations_research::OptionalDouble* _internal_mutable_relative_mip_gap();
  public:
  void unsafe_arena_set_allocated_relative_mip_gap(
      ::operations_research::OptionalDouble* relative_mip_gap);
  ::operations_research::OptionalDouble* unsafe_arena_release_relative_mip_gap();
 
  // optional .operations_research.OptionalDouble primal_tolerance = 2;
  bool has_primal_tolerance() const;
  private:
  bool _internal_has_primal_tolerance() const;
  public:
  void clear_primal_tolerance();
  const ::operations_research::OptionalDouble& primal_tolerance() const;
  PROTOBUF_NODISCARD ::operations_research::OptionalDouble* release_primal_tolerance();
  ::operations_research::OptionalDouble* mutable_primal_tolerance();
  void set_allocated_primal_tolerance(::operations_research::OptionalDouble* primal_tolerance);
  private:
  const ::operations_research::OptionalDouble& _internal_primal_tolerance() const;
  ::operations_research::OptionalDouble* _internal_mutable_primal_tolerance();
  public:
  void unsafe_arena_set_allocated_primal_tolerance(
      ::operations_research::OptionalDouble* primal_tolerance);
  ::operations_research::OptionalDouble* unsafe_arena_release_primal_tolerance();
 
  // optional .operations_research.OptionalDouble dual_tolerance = 3;
  bool has_dual_tolerance() const;
  private:
  bool _internal_has_dual_tolerance() const;
  public:
  void clear_dual_tolerance();
  const ::operations_research::OptionalDouble& dual_tolerance() const;
  PROTOBUF_NODISCARD ::operations_research::OptionalDouble* release_dual_tolerance();
  ::operations_research::OptionalDouble* mutable_dual_tolerance();
  void set_allocated_dual_tolerance(::operations_research::OptionalDouble* dual_tolerance);
  private:
  const ::operations_research::OptionalDouble& _internal_dual_tolerance() const;
  ::operations_research::OptionalDouble* _internal_mutable_dual_tolerance();
  public:
  void unsafe_arena_set_allocated_dual_tolerance(
      ::operations_research::OptionalDouble* dual_tolerance);
  ::operations_research::OptionalDouble* unsafe_arena_release_dual_tolerance();
 
  // optional .operations_research.MPSolverCommonParameters.LPAlgorithmValues lp_algorithm = 4 [default = LP_ALGO_UNSPECIFIED];
  bool has_lp_algorithm() const;
  private:
  bool _internal_has_lp_algorithm() const;
  public:
  void clear_lp_algorithm();
  ::operations_research::MPSolverCommonParameters_LPAlgorithmValues lp_algorithm() const;
  void set_lp_algorithm(::operations_research::MPSolverCommonParameters_LPAlgorithmValues value);
  private:
  ::operations_research::MPSolverCommonParameters_LPAlgorithmValues _internal_lp_algorithm() const;
  void _internal_set_lp_algorithm(::operations_research::MPSolverCommonParameters_LPAlgorithmValues value);
  public:
 
  // optional .operations_research.OptionalBoolean presolve = 5 [default = BOOL_UNSPECIFIED];
  bool has_presolve() const;
  private:
  bool _internal_has_presolve() const;
  public:
  void clear_presolve();
  ::operations_research::OptionalBoolean presolve() const;
  void set_presolve(::operations_research::OptionalBoolean value);
  private:
  ::operations_research::OptionalBoolean _internal_presolve() const;
  void _internal_set_presolve(::operations_research::OptionalBoolean value);
  public:
 
  // optional .operations_research.OptionalBoolean scaling = 7 [default = BOOL_UNSPECIFIED];
  bool has_scaling() const;
  private:
  bool _internal_has_scaling() const;
  public:
  void clear_scaling();
  ::operations_research::OptionalBoolean scaling() const;
  void set_scaling(::operations_research::OptionalBoolean value);
  private:
  ::operations_research::OptionalBoolean _internal_scaling() const;
  void _internal_set_scaling(::operations_research::OptionalBoolean value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPSolverCommonParameters)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::operations_research::OptionalDouble* relative_mip_gap_;
  ::operations_research::OptionalDouble* primal_tolerance_;
  ::operations_research::OptionalDouble* dual_tolerance_;
  int lp_algorithm_;
  int presolve_;
  int scaling_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPModelDeltaProto_VariableOverridesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MPModelDeltaProto_VariableOverridesEntry_DoNotUse, 
    int32_t, ::operations_research::MPVariableProto,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MPModelDeltaProto_VariableOverridesEntry_DoNotUse, 
    int32_t, ::operations_research::MPVariableProto,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  MPModelDeltaProto_VariableOverridesEntry_DoNotUse();
  explicit constexpr MPModelDeltaProto_VariableOverridesEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MPModelDeltaProto_VariableOverridesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MPModelDeltaProto_VariableOverridesEntry_DoNotUse& other);
  static const MPModelDeltaProto_VariableOverridesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MPModelDeltaProto_VariableOverridesEntry_DoNotUse*>(&_MPModelDeltaProto_VariableOverridesEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(void*) { return true; }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};
 
// -------------------------------------------------------------------
 
class MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse, 
    int32_t, ::operations_research::MPConstraintProto,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse, 
    int32_t, ::operations_research::MPConstraintProto,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse();
  explicit constexpr MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse& other);
  static const MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse*>(&_MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(void*) { return true; }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};
 
// -------------------------------------------------------------------
 
class MPModelDeltaProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPModelDeltaProto) */ {
 public:
  inline MPModelDeltaProto() : MPModelDeltaProto(nullptr) {}
  ~MPModelDeltaProto() override;
  explicit constexpr MPModelDeltaProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPModelDeltaProto(const MPModelDeltaProto& from);
  MPModelDeltaProto(MPModelDeltaProto&& from) noexcept
    : MPModelDeltaProto() {
    *this = ::std::move(from);
  }
 
  inline MPModelDeltaProto& operator=(const MPModelDeltaProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPModelDeltaProto& operator=(MPModelDeltaProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPModelDeltaProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPModelDeltaProto* internal_default_instance() {
    return reinterpret_cast<const MPModelDeltaProto*>(
               &_MPModelDeltaProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;
 
  friend void swap(MPModelDeltaProto& a, MPModelDeltaProto& b) {
    a.Swap(&b);
  }
  inline void Swap(MPModelDeltaProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPModelDeltaProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPModelDeltaProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPModelDeltaProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPModelDeltaProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPModelDeltaProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPModelDeltaProto* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPModelDeltaProto";
  }
  protected:
  explicit MPModelDeltaProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kVariableOverridesFieldNumber = 2,
    kConstraintOverridesFieldNumber = 3,
    kBaselineModelFilePathFieldNumber = 1,
  };
  // map<int32, .operations_research.MPVariableProto> variable_overrides = 2;
  int variable_overrides_size() const;
  private:
  int _internal_variable_overrides_size() const;
  public:
  void clear_variable_overrides();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPVariableProto >&
      _internal_variable_overrides() const;
  ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPVariableProto >*
      _internal_mutable_variable_overrides();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPVariableProto >&
      variable_overrides() const;
  ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPVariableProto >*
      mutable_variable_overrides();
 
  // map<int32, .operations_research.MPConstraintProto> constraint_overrides = 3;
  int constraint_overrides_size() const;
  private:
  int _internal_constraint_overrides_size() const;
  public:
  void clear_constraint_overrides();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPConstraintProto >&
      _internal_constraint_overrides() const;
  ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPConstraintProto >*
      _internal_mutable_constraint_overrides();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPConstraintProto >&
      constraint_overrides() const;
  ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPConstraintProto >*
      mutable_constraint_overrides();
 
  // optional string baseline_model_file_path = 1;
  bool has_baseline_model_file_path() const;
  private:
  bool _internal_has_baseline_model_file_path() const;
  public:
  void clear_baseline_model_file_path();
  const std::string& baseline_model_file_path() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_baseline_model_file_path(ArgT0&& arg0, ArgT... args);
  std::string* mutable_baseline_model_file_path();
  PROTOBUF_NODISCARD std::string* release_baseline_model_file_path();
  void set_allocated_baseline_model_file_path(std::string* baseline_model_file_path);
  private:
  const std::string& _internal_baseline_model_file_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_baseline_model_file_path(const std::string& value);
  std::string* _internal_mutable_baseline_model_file_path();
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPModelDeltaProto)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      MPModelDeltaProto_VariableOverridesEntry_DoNotUse,
      int32_t, ::operations_research::MPVariableProto,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> variable_overrides_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse,
      int32_t, ::operations_research::MPConstraintProto,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> constraint_overrides_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr baseline_model_file_path_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPModelRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPModelRequest) */ {
 public:
  inline MPModelRequest() : MPModelRequest(nullptr) {}
  ~MPModelRequest() override;
  explicit constexpr MPModelRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPModelRequest(const MPModelRequest& from);
  MPModelRequest(MPModelRequest&& from) noexcept
    : MPModelRequest() {
    *this = ::std::move(from);
  }
 
  inline MPModelRequest& operator=(const MPModelRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPModelRequest& operator=(MPModelRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPModelRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPModelRequest* internal_default_instance() {
    return reinterpret_cast<const MPModelRequest*>(
               &_MPModelRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;
 
  friend void swap(MPModelRequest& a, MPModelRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(MPModelRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPModelRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPModelRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPModelRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPModelRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPModelRequest& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPModelRequest* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPModelRequest";
  }
  protected:
  explicit MPModelRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef MPModelRequest_SolverType SolverType;
  static constexpr SolverType GLOP_LINEAR_PROGRAMMING =
    MPModelRequest_SolverType_GLOP_LINEAR_PROGRAMMING;
  static constexpr SolverType CLP_LINEAR_PROGRAMMING =
    MPModelRequest_SolverType_CLP_LINEAR_PROGRAMMING;
  static constexpr SolverType GLPK_LINEAR_PROGRAMMING =
    MPModelRequest_SolverType_GLPK_LINEAR_PROGRAMMING;
  static constexpr SolverType GUROBI_LINEAR_PROGRAMMING =
    MPModelRequest_SolverType_GUROBI_LINEAR_PROGRAMMING;
  static constexpr SolverType XPRESS_LINEAR_PROGRAMMING =
    MPModelRequest_SolverType_XPRESS_LINEAR_PROGRAMMING;
  static constexpr SolverType CPLEX_LINEAR_PROGRAMMING =
    MPModelRequest_SolverType_CPLEX_LINEAR_PROGRAMMING;
  static constexpr SolverType SCIP_MIXED_INTEGER_PROGRAMMING =
    MPModelRequest_SolverType_SCIP_MIXED_INTEGER_PROGRAMMING;
  static constexpr SolverType GLPK_MIXED_INTEGER_PROGRAMMING =
    MPModelRequest_SolverType_GLPK_MIXED_INTEGER_PROGRAMMING;
  static constexpr SolverType CBC_MIXED_INTEGER_PROGRAMMING =
    MPModelRequest_SolverType_CBC_MIXED_INTEGER_PROGRAMMING;
  static constexpr SolverType GUROBI_MIXED_INTEGER_PROGRAMMING =
    MPModelRequest_SolverType_GUROBI_MIXED_INTEGER_PROGRAMMING;
  static constexpr SolverType XPRESS_MIXED_INTEGER_PROGRAMMING =
    MPModelRequest_SolverType_XPRESS_MIXED_INTEGER_PROGRAMMING;
  static constexpr SolverType CPLEX_MIXED_INTEGER_PROGRAMMING =
    MPModelRequest_SolverType_CPLEX_MIXED_INTEGER_PROGRAMMING;
  static constexpr SolverType BOP_INTEGER_PROGRAMMING =
    MPModelRequest_SolverType_BOP_INTEGER_PROGRAMMING;
  static constexpr SolverType SAT_INTEGER_PROGRAMMING =
    MPModelRequest_SolverType_SAT_INTEGER_PROGRAMMING;
  static constexpr SolverType KNAPSACK_MIXED_INTEGER_PROGRAMMING =
    MPModelRequest_SolverType_KNAPSACK_MIXED_INTEGER_PROGRAMMING;
  static inline bool SolverType_IsValid(int value) {
    return MPModelRequest_SolverType_IsValid(value);
  }
  static constexpr SolverType SolverType_MIN =
    MPModelRequest_SolverType_SolverType_MIN;
  static constexpr SolverType SolverType_MAX =
    MPModelRequest_SolverType_SolverType_MAX;
  static constexpr int SolverType_ARRAYSIZE =
    MPModelRequest_SolverType_SolverType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SolverType_descriptor() {
    return MPModelRequest_SolverType_descriptor();
  }
  template<typename T>
  static inline const std::string& SolverType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SolverType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SolverType_Name.");
    return MPModelRequest_SolverType_Name(enum_t_value);
  }
  static inline bool SolverType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      SolverType* value) {
    return MPModelRequest_SolverType_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kSolverSpecificParametersFieldNumber = 5,
    kModelFieldNumber = 1,
    kModelDeltaFieldNumber = 8,
    kSolverTimeLimitSecondsFieldNumber = 3,
    kEnableInternalSolverOutputFieldNumber = 4,
    kIgnoreSolverSpecificParametersFailureFieldNumber = 9,
    kPopulateAdditionalSolutionsUpToFieldNumber = 11,
    kSolverTypeFieldNumber = 2,
  };
  // optional string solver_specific_parameters = 5;
  bool has_solver_specific_parameters() const;
  private:
  bool _internal_has_solver_specific_parameters() const;
  public:
  void clear_solver_specific_parameters();
  const std::string& solver_specific_parameters() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_solver_specific_parameters(ArgT0&& arg0, ArgT... args);
  std::string* mutable_solver_specific_parameters();
  PROTOBUF_NODISCARD std::string* release_solver_specific_parameters();
  void set_allocated_solver_specific_parameters(std::string* solver_specific_parameters);
  private:
  const std::string& _internal_solver_specific_parameters() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_solver_specific_parameters(const std::string& value);
  std::string* _internal_mutable_solver_specific_parameters();
  public:
 
  // optional .operations_research.MPModelProto model = 1;
  bool has_model() const;
  private:
  bool _internal_has_model() const;
  public:
  void clear_model();
  const ::operations_research::MPModelProto& model() const;
  PROTOBUF_NODISCARD ::operations_research::MPModelProto* release_model();
  ::operations_research::MPModelProto* mutable_model();
  void set_allocated_model(::operations_research::MPModelProto* model);
  private:
  const ::operations_research::MPModelProto& _internal_model() const;
  ::operations_research::MPModelProto* _internal_mutable_model();
  public:
  void unsafe_arena_set_allocated_model(
      ::operations_research::MPModelProto* model);
  ::operations_research::MPModelProto* unsafe_arena_release_model();
 
  // optional .operations_research.MPModelDeltaProto model_delta = 8;
  bool has_model_delta() const;
  private:
  bool _internal_has_model_delta() const;
  public:
  void clear_model_delta();
  const ::operations_research::MPModelDeltaProto& model_delta() const;
  PROTOBUF_NODISCARD ::operations_research::MPModelDeltaProto* release_model_delta();
  ::operations_research::MPModelDeltaProto* mutable_model_delta();
  void set_allocated_model_delta(::operations_research::MPModelDeltaProto* model_delta);
  private:
  const ::operations_research::MPModelDeltaProto& _internal_model_delta() const;
  ::operations_research::MPModelDeltaProto* _internal_mutable_model_delta();
  public:
  void unsafe_arena_set_allocated_model_delta(
      ::operations_research::MPModelDeltaProto* model_delta);
  ::operations_research::MPModelDeltaProto* unsafe_arena_release_model_delta();
 
  // optional double solver_time_limit_seconds = 3;
  bool has_solver_time_limit_seconds() const;
  private:
  bool _internal_has_solver_time_limit_seconds() const;
  public:
  void clear_solver_time_limit_seconds();
  double solver_time_limit_seconds() const;
  void set_solver_time_limit_seconds(double value);
  private:
  double _internal_solver_time_limit_seconds() const;
  void _internal_set_solver_time_limit_seconds(double value);
  public:
 
  // optional bool enable_internal_solver_output = 4 [default = false];
  bool has_enable_internal_solver_output() const;
  private:
  bool _internal_has_enable_internal_solver_output() const;
  public:
  void clear_enable_internal_solver_output();
  bool enable_internal_solver_output() const;
  void set_enable_internal_solver_output(bool value);
  private:
  bool _internal_enable_internal_solver_output() const;
  void _internal_set_enable_internal_solver_output(bool value);
  public:
 
  // optional bool ignore_solver_specific_parameters_failure = 9 [default = false];
  bool has_ignore_solver_specific_parameters_failure() const;
  private:
  bool _internal_has_ignore_solver_specific_parameters_failure() const;
  public:
  void clear_ignore_solver_specific_parameters_failure();
  bool ignore_solver_specific_parameters_failure() const;
  void set_ignore_solver_specific_parameters_failure(bool value);
  private:
  bool _internal_ignore_solver_specific_parameters_failure() const;
  void _internal_set_ignore_solver_specific_parameters_failure(bool value);
  public:
 
  // optional int32 populate_additional_solutions_up_to = 11 [default = 0];
  bool has_populate_additional_solutions_up_to() const;
  private:
  bool _internal_has_populate_additional_solutions_up_to() const;
  public:
  void clear_populate_additional_solutions_up_to();
  int32_t populate_additional_solutions_up_to() const;
  void set_populate_additional_solutions_up_to(int32_t value);
  private:
  int32_t _internal_populate_additional_solutions_up_to() const;
  void _internal_set_populate_additional_solutions_up_to(int32_t value);
  public:
 
  // optional .operations_research.MPModelRequest.SolverType solver_type = 2;
  bool has_solver_type() const;
  private:
  bool _internal_has_solver_type() const;
  public:
  void clear_solver_type();
  ::operations_research::MPModelRequest_SolverType solver_type() const;
  void set_solver_type(::operations_research::MPModelRequest_SolverType value);
  private:
  ::operations_research::MPModelRequest_SolverType _internal_solver_type() const;
  void _internal_set_solver_type(::operations_research::MPModelRequest_SolverType value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPModelRequest)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr solver_specific_parameters_;
  ::operations_research::MPModelProto* model_;
  ::operations_research::MPModelDeltaProto* model_delta_;
  double solver_time_limit_seconds_;
  bool enable_internal_solver_output_;
  bool ignore_solver_specific_parameters_failure_;
  int32_t populate_additional_solutions_up_to_;
  int solver_type_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPSolution final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPSolution) */ {
 public:
  inline MPSolution() : MPSolution(nullptr) {}
  ~MPSolution() override;
  explicit constexpr MPSolution(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPSolution(const MPSolution& from);
  MPSolution(MPSolution&& from) noexcept
    : MPSolution() {
    *this = ::std::move(from);
  }
 
  inline MPSolution& operator=(const MPSolution& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPSolution& operator=(MPSolution&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPSolution& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPSolution* internal_default_instance() {
    return reinterpret_cast<const MPSolution*>(
               &_MPSolution_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;
 
  friend void swap(MPSolution& a, MPSolution& b) {
    a.Swap(&b);
  }
  inline void Swap(MPSolution* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPSolution* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPSolution* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPSolution>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPSolution& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPSolution& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPSolution* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPSolution";
  }
  protected:
  explicit MPSolution(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kVariableValueFieldNumber = 2,
    kObjectiveValueFieldNumber = 1,
  };
  // repeated double variable_value = 2 [packed = true];
  int variable_value_size() const;
  private:
  int _internal_variable_value_size() const;
  public:
  void clear_variable_value();
  private:
  double _internal_variable_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_variable_value() const;
  void _internal_add_variable_value(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_variable_value();
  public:
  double variable_value(int index) const;
  void set_variable_value(int index, double value);
  void add_variable_value(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      variable_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_variable_value();
 
  // optional double objective_value = 1;
  bool has_objective_value() const;
  private:
  bool _internal_has_objective_value() const;
  public:
  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:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPSolution)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > variable_value_;
  double objective_value_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPSolveInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPSolveInfo) */ {
 public:
  inline MPSolveInfo() : MPSolveInfo(nullptr) {}
  ~MPSolveInfo() override;
  explicit constexpr MPSolveInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPSolveInfo(const MPSolveInfo& from);
  MPSolveInfo(MPSolveInfo&& from) noexcept
    : MPSolveInfo() {
    *this = ::std::move(from);
  }
 
  inline MPSolveInfo& operator=(const MPSolveInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPSolveInfo& operator=(MPSolveInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPSolveInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPSolveInfo* internal_default_instance() {
    return reinterpret_cast<const MPSolveInfo*>(
               &_MPSolveInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;
 
  friend void swap(MPSolveInfo& a, MPSolveInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(MPSolveInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPSolveInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPSolveInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPSolveInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPSolveInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPSolveInfo& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPSolveInfo* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPSolveInfo";
  }
  protected:
  explicit MPSolveInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kSolveWallTimeSecondsFieldNumber = 1,
    kSolveUserTimeSecondsFieldNumber = 2,
  };
  // optional double solve_wall_time_seconds = 1;
  bool has_solve_wall_time_seconds() const;
  private:
  bool _internal_has_solve_wall_time_seconds() const;
  public:
  void clear_solve_wall_time_seconds();
  double solve_wall_time_seconds() const;
  void set_solve_wall_time_seconds(double value);
  private:
  double _internal_solve_wall_time_seconds() const;
  void _internal_set_solve_wall_time_seconds(double value);
  public:
 
  // optional double solve_user_time_seconds = 2;
  bool has_solve_user_time_seconds() const;
  private:
  bool _internal_has_solve_user_time_seconds() const;
  public:
  void clear_solve_user_time_seconds();
  double solve_user_time_seconds() const;
  void set_solve_user_time_seconds(double value);
  private:
  double _internal_solve_user_time_seconds() const;
  void _internal_set_solve_user_time_seconds(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPSolveInfo)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  double solve_wall_time_seconds_;
  double solve_user_time_seconds_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------
 
class MPSolutionResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPSolutionResponse) */ {
 public:
  inline MPSolutionResponse() : MPSolutionResponse(nullptr) {}
  ~MPSolutionResponse() override;
  explicit constexpr MPSolutionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MPSolutionResponse(const MPSolutionResponse& from);
  MPSolutionResponse(MPSolutionResponse&& from) noexcept
    : MPSolutionResponse() {
    *this = ::std::move(from);
  }
 
  inline MPSolutionResponse& operator=(const MPSolutionResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPSolutionResponse& operator=(MPSolutionResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MPSolutionResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPSolutionResponse* internal_default_instance() {
    return reinterpret_cast<const MPSolutionResponse*>(
               &_MPSolutionResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;
 
  friend void swap(MPSolutionResponse& a, MPSolutionResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(MPSolutionResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MPSolutionResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MPSolutionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPSolutionResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPSolutionResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MPSolutionResponse& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPSolutionResponse* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPSolutionResponse";
  }
  protected:
  explicit MPSolutionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kVariableValueFieldNumber = 3,
    kDualValueFieldNumber = 4,
    kReducedCostFieldNumber = 6,
    kAdditionalSolutionsFieldNumber = 8,
    kStatusStrFieldNumber = 7,
    kSolveInfoFieldNumber = 10,
    kObjectiveValueFieldNumber = 2,
    kBestObjectiveBoundFieldNumber = 5,
    kStatusFieldNumber = 1,
  };
  // repeated double variable_value = 3 [packed = true];
  int variable_value_size() const;
  private:
  int _internal_variable_value_size() const;
  public:
  void clear_variable_value();
  private:
  double _internal_variable_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_variable_value() const;
  void _internal_add_variable_value(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_variable_value();
  public:
  double variable_value(int index) const;
  void set_variable_value(int index, double value);
  void add_variable_value(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      variable_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_variable_value();
 
  // repeated double dual_value = 4 [packed = true];
  int dual_value_size() const;
  private:
  int _internal_dual_value_size() const;
  public:
  void clear_dual_value();
  private:
  double _internal_dual_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_dual_value() const;
  void _internal_add_dual_value(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_dual_value();
  public:
  double dual_value(int index) const;
  void set_dual_value(int index, double value);
  void add_dual_value(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      dual_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_dual_value();
 
  // repeated double reduced_cost = 6 [packed = true];
  int reduced_cost_size() const;
  private:
  int _internal_reduced_cost_size() const;
  public:
  void clear_reduced_cost();
  private:
  double _internal_reduced_cost(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_reduced_cost() const;
  void _internal_add_reduced_cost(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_reduced_cost();
  public:
  double reduced_cost(int index) const;
  void set_reduced_cost(int index, double value);
  void add_reduced_cost(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      reduced_cost() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_reduced_cost();
 
  // repeated .operations_research.MPSolution additional_solutions = 8;
  int additional_solutions_size() const;
  private:
  int _internal_additional_solutions_size() const;
  public:
  void clear_additional_solutions();
  ::operations_research::MPSolution* mutable_additional_solutions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPSolution >*
      mutable_additional_solutions();
  private:
  const ::operations_research::MPSolution& _internal_additional_solutions(int index) const;
  ::operations_research::MPSolution* _internal_add_additional_solutions();
  public:
  const ::operations_research::MPSolution& additional_solutions(int index) const;
  ::operations_research::MPSolution* add_additional_solutions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPSolution >&
      additional_solutions() const;
 
  // optional string status_str = 7;
  bool has_status_str() const;
  private:
  bool _internal_has_status_str() const;
  public:
  void clear_status_str();
  const std::string& status_str() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_status_str(ArgT0&& arg0, ArgT... args);
  std::string* mutable_status_str();
  PROTOBUF_NODISCARD std::string* release_status_str();
  void set_allocated_status_str(std::string* status_str);
  private:
  const std::string& _internal_status_str() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_status_str(const std::string& value);
  std::string* _internal_mutable_status_str();
  public:
 
  // optional .operations_research.MPSolveInfo solve_info = 10;
  bool has_solve_info() const;
  private:
  bool _internal_has_solve_info() const;
  public:
  void clear_solve_info();
  const ::operations_research::MPSolveInfo& solve_info() const;
  PROTOBUF_NODISCARD ::operations_research::MPSolveInfo* release_solve_info();
  ::operations_research::MPSolveInfo* mutable_solve_info();
  void set_allocated_solve_info(::operations_research::MPSolveInfo* solve_info);
  private:
  const ::operations_research::MPSolveInfo& _internal_solve_info() const;
  ::operations_research::MPSolveInfo* _internal_mutable_solve_info();
  public:
  void unsafe_arena_set_allocated_solve_info(
      ::operations_research::MPSolveInfo* solve_info);
  ::operations_research::MPSolveInfo* unsafe_arena_release_solve_info();
 
  // optional double objective_value = 2;
  bool has_objective_value() const;
  private:
  bool _internal_has_objective_value() const;
  public:
  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:
 
  // optional double best_objective_bound = 5;
  bool has_best_objective_bound() const;
  private:
  bool _internal_has_best_objective_bound() const;
  public:
  void clear_best_objective_bound();
  double best_objective_bound() const;
  void set_best_objective_bound(double value);
  private:
  double _internal_best_objective_bound() const;
  void _internal_set_best_objective_bound(double value);
  public:
 
  // optional .operations_research.MPSolverResponseStatus status = 1 [default = MPSOLVER_UNKNOWN_STATUS];
  bool has_status() const;
  private:
  bool _internal_has_status() const;
  public:
  void clear_status();
  ::operations_research::MPSolverResponseStatus status() const;
  void set_status(::operations_research::MPSolverResponseStatus value);
  private:
  ::operations_research::MPSolverResponseStatus _internal_status() const;
  void _internal_set_status(::operations_research::MPSolverResponseStatus value);
  public:
 
  // @@protoc_insertion_point(class_scope:operations_research.MPSolutionResponse)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > variable_value_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > dual_value_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > reduced_cost_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPSolution > additional_solutions_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr status_str_;
  ::operations_research::MPSolveInfo* solve_info_;
  double objective_value_;
  double best_objective_bound_;
  int status_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// MPVariableProto
 
// optional double lower_bound = 1 [default = -inf];
inline bool MPVariableProto::_internal_has_lower_bound() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool MPVariableProto::has_lower_bound() const {
  return _internal_has_lower_bound();
}
inline void MPVariableProto::clear_lower_bound() {
  lower_bound_ = -std::numeric_limits<double>::infinity();
  _has_bits_[0] &= ~0x00000010u;
}
inline double MPVariableProto::_internal_lower_bound() const {
  return lower_bound_;
}
inline double MPVariableProto::lower_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.lower_bound)
  return _internal_lower_bound();
}
inline void MPVariableProto::_internal_set_lower_bound(double value) {
  _has_bits_[0] |= 0x00000010u;
  lower_bound_ = value;
}
inline void MPVariableProto::set_lower_bound(double value) {
  _internal_set_lower_bound(value);
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.lower_bound)
}
 
// optional double upper_bound = 2 [default = inf];
inline bool MPVariableProto::_internal_has_upper_bound() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool MPVariableProto::has_upper_bound() const {
  return _internal_has_upper_bound();
}
inline void MPVariableProto::clear_upper_bound() {
  upper_bound_ = std::numeric_limits<double>::infinity();
  _has_bits_[0] &= ~0x00000020u;
}
inline double MPVariableProto::_internal_upper_bound() const {
  return upper_bound_;
}
inline double MPVariableProto::upper_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.upper_bound)
  return _internal_upper_bound();
}
inline void MPVariableProto::_internal_set_upper_bound(double value) {
  _has_bits_[0] |= 0x00000020u;
  upper_bound_ = value;
}
inline void MPVariableProto::set_upper_bound(double value) {
  _internal_set_upper_bound(value);
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.upper_bound)
}
 
// optional double objective_coefficient = 3 [default = 0];
inline bool MPVariableProto::_internal_has_objective_coefficient() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MPVariableProto::has_objective_coefficient() const {
  return _internal_has_objective_coefficient();
}
inline void MPVariableProto::clear_objective_coefficient() {
  objective_coefficient_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline double MPVariableProto::_internal_objective_coefficient() const {
  return objective_coefficient_;
}
inline double MPVariableProto::objective_coefficient() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.objective_coefficient)
  return _internal_objective_coefficient();
}
inline void MPVariableProto::_internal_set_objective_coefficient(double value) {
  _has_bits_[0] |= 0x00000002u;
  objective_coefficient_ = value;
}
inline void MPVariableProto::set_objective_coefficient(double value) {
  _internal_set_objective_coefficient(value);
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.objective_coefficient)
}
 
// optional bool is_integer = 4 [default = false];
inline bool MPVariableProto::_internal_has_is_integer() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MPVariableProto::has_is_integer() const {
  return _internal_has_is_integer();
}
inline void MPVariableProto::clear_is_integer() {
  is_integer_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool MPVariableProto::_internal_is_integer() const {
  return is_integer_;
}
inline bool MPVariableProto::is_integer() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.is_integer)
  return _internal_is_integer();
}
inline void MPVariableProto::_internal_set_is_integer(bool value) {
  _has_bits_[0] |= 0x00000004u;
  is_integer_ = value;
}
inline void MPVariableProto::set_is_integer(bool value) {
  _internal_set_is_integer(value);
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.is_integer)
}
 
// optional string name = 5 [default = ""];
inline bool MPVariableProto::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPVariableProto::has_name() const {
  return _internal_has_name();
}
inline void MPVariableProto::clear_name() {
  name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MPVariableProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MPVariableProto::set_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.name)
}
inline std::string* MPVariableProto::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:operations_research.MPVariableProto.name)
  return _s;
}
inline const std::string& MPVariableProto::_internal_name() const {
  return name_.Get();
}
inline void MPVariableProto::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* MPVariableProto::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* MPVariableProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.MPVariableProto.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MPVariableProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPVariableProto.name)
}
 
// optional int32 branching_priority = 6 [default = 0];
inline bool MPVariableProto::_internal_has_branching_priority() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MPVariableProto::has_branching_priority() const {
  return _internal_has_branching_priority();
}
inline void MPVariableProto::clear_branching_priority() {
  branching_priority_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline int32_t MPVariableProto::_internal_branching_priority() const {
  return branching_priority_;
}
inline int32_t MPVariableProto::branching_priority() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.branching_priority)
  return _internal_branching_priority();
}
inline void MPVariableProto::_internal_set_branching_priority(int32_t value) {
  _has_bits_[0] |= 0x00000008u;
  branching_priority_ = value;
}
inline void MPVariableProto::set_branching_priority(int32_t value) {
  _internal_set_branching_priority(value);
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.branching_priority)
}
 
// -------------------------------------------------------------------
 
// MPConstraintProto
 
// repeated int32 var_index = 6 [packed = true];
inline int MPConstraintProto::_internal_var_index_size() const {
  return var_index_.size();
}
inline int MPConstraintProto::var_index_size() const {
  return _internal_var_index_size();
}
inline void MPConstraintProto::clear_var_index() {
  var_index_.Clear();
}
inline int32_t MPConstraintProto::_internal_var_index(int index) const {
  return var_index_.Get(index);
}
inline int32_t MPConstraintProto::var_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.var_index)
  return _internal_var_index(index);
}
inline void MPConstraintProto::set_var_index(int index, int32_t value) {
  var_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPConstraintProto.var_index)
}
inline void MPConstraintProto::_internal_add_var_index(int32_t value) {
  var_index_.Add(value);
}
inline void MPConstraintProto::add_var_index(int32_t value) {
  _internal_add_var_index(value);
  // @@protoc_insertion_point(field_add:operations_research.MPConstraintProto.var_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPConstraintProto::_internal_var_index() const {
  return var_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPConstraintProto::var_index() const {
  // @@protoc_insertion_point(field_list:operations_research.MPConstraintProto.var_index)
  return _internal_var_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPConstraintProto::_internal_mutable_var_index() {
  return &var_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPConstraintProto::mutable_var_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPConstraintProto.var_index)
  return _internal_mutable_var_index();
}
 
// repeated double coefficient = 7 [packed = true];
inline int MPConstraintProto::_internal_coefficient_size() const {
  return coefficient_.size();
}
inline int MPConstraintProto::coefficient_size() const {
  return _internal_coefficient_size();
}
inline void MPConstraintProto::clear_coefficient() {
  coefficient_.Clear();
}
inline double MPConstraintProto::_internal_coefficient(int index) const {
  return coefficient_.Get(index);
}
inline double MPConstraintProto::coefficient(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.coefficient)
  return _internal_coefficient(index);
}
inline void MPConstraintProto::set_coefficient(int index, double value) {
  coefficient_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPConstraintProto.coefficient)
}
inline void MPConstraintProto::_internal_add_coefficient(double value) {
  coefficient_.Add(value);
}
inline void MPConstraintProto::add_coefficient(double value) {
  _internal_add_coefficient(value);
  // @@protoc_insertion_point(field_add:operations_research.MPConstraintProto.coefficient)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPConstraintProto::_internal_coefficient() const {
  return coefficient_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPConstraintProto::coefficient() const {
  // @@protoc_insertion_point(field_list:operations_research.MPConstraintProto.coefficient)
  return _internal_coefficient();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPConstraintProto::_internal_mutable_coefficient() {
  return &coefficient_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPConstraintProto::mutable_coefficient() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPConstraintProto.coefficient)
  return _internal_mutable_coefficient();
}
 
// optional double lower_bound = 2 [default = -inf];
inline bool MPConstraintProto::_internal_has_lower_bound() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MPConstraintProto::has_lower_bound() const {
  return _internal_has_lower_bound();
}
inline void MPConstraintProto::clear_lower_bound() {
  lower_bound_ = -std::numeric_limits<double>::infinity();
  _has_bits_[0] &= ~0x00000004u;
}
inline double MPConstraintProto::_internal_lower_bound() const {
  return lower_bound_;
}
inline double MPConstraintProto::lower_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.lower_bound)
  return _internal_lower_bound();
}
inline void MPConstraintProto::_internal_set_lower_bound(double value) {
  _has_bits_[0] |= 0x00000004u;
  lower_bound_ = value;
}
inline void MPConstraintProto::set_lower_bound(double value) {
  _internal_set_lower_bound(value);
  // @@protoc_insertion_point(field_set:operations_research.MPConstraintProto.lower_bound)
}
 
// optional double upper_bound = 3 [default = inf];
inline bool MPConstraintProto::_internal_has_upper_bound() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MPConstraintProto::has_upper_bound() const {
  return _internal_has_upper_bound();
}
inline void MPConstraintProto::clear_upper_bound() {
  upper_bound_ = std::numeric_limits<double>::infinity();
  _has_bits_[0] &= ~0x00000008u;
}
inline double MPConstraintProto::_internal_upper_bound() const {
  return upper_bound_;
}
inline double MPConstraintProto::upper_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.upper_bound)
  return _internal_upper_bound();
}
inline void MPConstraintProto::_internal_set_upper_bound(double value) {
  _has_bits_[0] |= 0x00000008u;
  upper_bound_ = value;
}
inline void MPConstraintProto::set_upper_bound(double value) {
  _internal_set_upper_bound(value);
  // @@protoc_insertion_point(field_set:operations_research.MPConstraintProto.upper_bound)
}
 
// optional string name = 4 [default = ""];
inline bool MPConstraintProto::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPConstraintProto::has_name() const {
  return _internal_has_name();
}
inline void MPConstraintProto::clear_name() {
  name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MPConstraintProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MPConstraintProto::set_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.MPConstraintProto.name)
}
inline std::string* MPConstraintProto::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:operations_research.MPConstraintProto.name)
  return _s;
}
inline const std::string& MPConstraintProto::_internal_name() const {
  return name_.Get();
}
inline void MPConstraintProto::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* MPConstraintProto::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* MPConstraintProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.MPConstraintProto.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MPConstraintProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPConstraintProto.name)
}
 
// optional bool is_lazy = 5 [default = false];
inline bool MPConstraintProto::_internal_has_is_lazy() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MPConstraintProto::has_is_lazy() const {
  return _internal_has_is_lazy();
}
inline void MPConstraintProto::clear_is_lazy() {
  is_lazy_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool MPConstraintProto::_internal_is_lazy() const {
  return is_lazy_;
}
inline bool MPConstraintProto::is_lazy() const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.is_lazy)
  return _internal_is_lazy();
}
inline void MPConstraintProto::_internal_set_is_lazy(bool value) {
  _has_bits_[0] |= 0x00000002u;
  is_lazy_ = value;
}
inline void MPConstraintProto::set_is_lazy(bool value) {
  _internal_set_is_lazy(value);
  // @@protoc_insertion_point(field_set:operations_research.MPConstraintProto.is_lazy)
}
 
// -------------------------------------------------------------------
 
// MPGeneralConstraintProto
 
// optional string name = 1 [default = ""];
inline bool MPGeneralConstraintProto::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPGeneralConstraintProto::has_name() const {
  return _internal_has_name();
}
inline void MPGeneralConstraintProto::clear_name() {
  name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MPGeneralConstraintProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MPGeneralConstraintProto::set_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.MPGeneralConstraintProto.name)
}
inline std::string* MPGeneralConstraintProto::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.name)
  return _s;
}
inline const std::string& MPGeneralConstraintProto::_internal_name() const {
  return name_.Get();
}
inline void MPGeneralConstraintProto::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* MPGeneralConstraintProto::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* MPGeneralConstraintProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.MPGeneralConstraintProto.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MPGeneralConstraintProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPGeneralConstraintProto.name)
}
 
// .operations_research.MPIndicatorConstraint indicator_constraint = 2;
inline bool MPGeneralConstraintProto::_internal_has_indicator_constraint() const {
  return general_constraint_case() == kIndicatorConstraint;
}
inline bool MPGeneralConstraintProto::has_indicator_constraint() const {
  return _internal_has_indicator_constraint();
}
inline void MPGeneralConstraintProto::set_has_indicator_constraint() {
  _oneof_case_[0] = kIndicatorConstraint;
}
inline void MPGeneralConstraintProto::clear_indicator_constraint() {
  if (_internal_has_indicator_constraint()) {
    if (GetArenaForAllocation() == nullptr) {
      delete general_constraint_.indicator_constraint_;
    }
    clear_has_general_constraint();
  }
}
inline ::operations_research::MPIndicatorConstraint* MPGeneralConstraintProto::release_indicator_constraint() {
  // @@protoc_insertion_point(field_release:operations_research.MPGeneralConstraintProto.indicator_constraint)
  if (_internal_has_indicator_constraint()) {
    clear_has_general_constraint();
      ::operations_research::MPIndicatorConstraint* temp = general_constraint_.indicator_constraint_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    general_constraint_.indicator_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::MPIndicatorConstraint& MPGeneralConstraintProto::_internal_indicator_constraint() const {
  return _internal_has_indicator_constraint()
      ? *general_constraint_.indicator_constraint_
      : reinterpret_cast< ::operations_research::MPIndicatorConstraint&>(::operations_research::_MPIndicatorConstraint_default_instance_);
}
inline const ::operations_research::MPIndicatorConstraint& MPGeneralConstraintProto::indicator_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.indicator_constraint)
  return _internal_indicator_constraint();
}
inline ::operations_research::MPIndicatorConstraint* MPGeneralConstraintProto::unsafe_arena_release_indicator_constraint() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.MPGeneralConstraintProto.indicator_constraint)
  if (_internal_has_indicator_constraint()) {
    clear_has_general_constraint();
    ::operations_research::MPIndicatorConstraint* temp = general_constraint_.indicator_constraint_;
    general_constraint_.indicator_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MPGeneralConstraintProto::unsafe_arena_set_allocated_indicator_constraint(::operations_research::MPIndicatorConstraint* indicator_constraint) {
  clear_general_constraint();
  if (indicator_constraint) {
    set_has_indicator_constraint();
    general_constraint_.indicator_constraint_ = indicator_constraint;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPGeneralConstraintProto.indicator_constraint)
}
inline ::operations_research::MPIndicatorConstraint* MPGeneralConstraintProto::_internal_mutable_indicator_constraint() {
  if (!_internal_has_indicator_constraint()) {
    clear_general_constraint();
    set_has_indicator_constraint();
    general_constraint_.indicator_constraint_ = CreateMaybeMessage< ::operations_research::MPIndicatorConstraint >(GetArenaForAllocation());
  }
  return general_constraint_.indicator_constraint_;
}
inline ::operations_research::MPIndicatorConstraint* MPGeneralConstraintProto::mutable_indicator_constraint() {
  ::operations_research::MPIndicatorConstraint* _msg = _internal_mutable_indicator_constraint();
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.indicator_constraint)
  return _msg;
}
 
// .operations_research.MPSosConstraint sos_constraint = 3;
inline bool MPGeneralConstraintProto::_internal_has_sos_constraint() const {
  return general_constraint_case() == kSosConstraint;
}
inline bool MPGeneralConstraintProto::has_sos_constraint() const {
  return _internal_has_sos_constraint();
}
inline void MPGeneralConstraintProto::set_has_sos_constraint() {
  _oneof_case_[0] = kSosConstraint;
}
inline void MPGeneralConstraintProto::clear_sos_constraint() {
  if (_internal_has_sos_constraint()) {
    if (GetArenaForAllocation() == nullptr) {
      delete general_constraint_.sos_constraint_;
    }
    clear_has_general_constraint();
  }
}
inline ::operations_research::MPSosConstraint* MPGeneralConstraintProto::release_sos_constraint() {
  // @@protoc_insertion_point(field_release:operations_research.MPGeneralConstraintProto.sos_constraint)
  if (_internal_has_sos_constraint()) {
    clear_has_general_constraint();
      ::operations_research::MPSosConstraint* temp = general_constraint_.sos_constraint_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    general_constraint_.sos_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::MPSosConstraint& MPGeneralConstraintProto::_internal_sos_constraint() const {
  return _internal_has_sos_constraint()
      ? *general_constraint_.sos_constraint_
      : reinterpret_cast< ::operations_research::MPSosConstraint&>(::operations_research::_MPSosConstraint_default_instance_);
}
inline const ::operations_research::MPSosConstraint& MPGeneralConstraintProto::sos_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.sos_constraint)
  return _internal_sos_constraint();
}
inline ::operations_research::MPSosConstraint* MPGeneralConstraintProto::unsafe_arena_release_sos_constraint() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.MPGeneralConstraintProto.sos_constraint)
  if (_internal_has_sos_constraint()) {
    clear_has_general_constraint();
    ::operations_research::MPSosConstraint* temp = general_constraint_.sos_constraint_;
    general_constraint_.sos_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MPGeneralConstraintProto::unsafe_arena_set_allocated_sos_constraint(::operations_research::MPSosConstraint* sos_constraint) {
  clear_general_constraint();
  if (sos_constraint) {
    set_has_sos_constraint();
    general_constraint_.sos_constraint_ = sos_constraint;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPGeneralConstraintProto.sos_constraint)
}
inline ::operations_research::MPSosConstraint* MPGeneralConstraintProto::_internal_mutable_sos_constraint() {
  if (!_internal_has_sos_constraint()) {
    clear_general_constraint();
    set_has_sos_constraint();
    general_constraint_.sos_constraint_ = CreateMaybeMessage< ::operations_research::MPSosConstraint >(GetArenaForAllocation());
  }
  return general_constraint_.sos_constraint_;
}
inline ::operations_research::MPSosConstraint* MPGeneralConstraintProto::mutable_sos_constraint() {
  ::operations_research::MPSosConstraint* _msg = _internal_mutable_sos_constraint();
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.sos_constraint)
  return _msg;
}
 
// .operations_research.MPQuadraticConstraint quadratic_constraint = 4;
inline bool MPGeneralConstraintProto::_internal_has_quadratic_constraint() const {
  return general_constraint_case() == kQuadraticConstraint;
}
inline bool MPGeneralConstraintProto::has_quadratic_constraint() const {
  return _internal_has_quadratic_constraint();
}
inline void MPGeneralConstraintProto::set_has_quadratic_constraint() {
  _oneof_case_[0] = kQuadraticConstraint;
}
inline void MPGeneralConstraintProto::clear_quadratic_constraint() {
  if (_internal_has_quadratic_constraint()) {
    if (GetArenaForAllocation() == nullptr) {
      delete general_constraint_.quadratic_constraint_;
    }
    clear_has_general_constraint();
  }
}
inline ::operations_research::MPQuadraticConstraint* MPGeneralConstraintProto::release_quadratic_constraint() {
  // @@protoc_insertion_point(field_release:operations_research.MPGeneralConstraintProto.quadratic_constraint)
  if (_internal_has_quadratic_constraint()) {
    clear_has_general_constraint();
      ::operations_research::MPQuadraticConstraint* temp = general_constraint_.quadratic_constraint_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    general_constraint_.quadratic_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::MPQuadraticConstraint& MPGeneralConstraintProto::_internal_quadratic_constraint() const {
  return _internal_has_quadratic_constraint()
      ? *general_constraint_.quadratic_constraint_
      : reinterpret_cast< ::operations_research::MPQuadraticConstraint&>(::operations_research::_MPQuadraticConstraint_default_instance_);
}
inline const ::operations_research::MPQuadraticConstraint& MPGeneralConstraintProto::quadratic_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.quadratic_constraint)
  return _internal_quadratic_constraint();
}
inline ::operations_research::MPQuadraticConstraint* MPGeneralConstraintProto::unsafe_arena_release_quadratic_constraint() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.MPGeneralConstraintProto.quadratic_constraint)
  if (_internal_has_quadratic_constraint()) {
    clear_has_general_constraint();
    ::operations_research::MPQuadraticConstraint* temp = general_constraint_.quadratic_constraint_;
    general_constraint_.quadratic_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MPGeneralConstraintProto::unsafe_arena_set_allocated_quadratic_constraint(::operations_research::MPQuadraticConstraint* quadratic_constraint) {
  clear_general_constraint();
  if (quadratic_constraint) {
    set_has_quadratic_constraint();
    general_constraint_.quadratic_constraint_ = quadratic_constraint;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPGeneralConstraintProto.quadratic_constraint)
}
inline ::operations_research::MPQuadraticConstraint* MPGeneralConstraintProto::_internal_mutable_quadratic_constraint() {
  if (!_internal_has_quadratic_constraint()) {
    clear_general_constraint();
    set_has_quadratic_constraint();
    general_constraint_.quadratic_constraint_ = CreateMaybeMessage< ::operations_research::MPQuadraticConstraint >(GetArenaForAllocation());
  }
  return general_constraint_.quadratic_constraint_;
}
inline ::operations_research::MPQuadraticConstraint* MPGeneralConstraintProto::mutable_quadratic_constraint() {
  ::operations_research::MPQuadraticConstraint* _msg = _internal_mutable_quadratic_constraint();
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.quadratic_constraint)
  return _msg;
}
 
// .operations_research.MPAbsConstraint abs_constraint = 5;
inline bool MPGeneralConstraintProto::_internal_has_abs_constraint() const {
  return general_constraint_case() == kAbsConstraint;
}
inline bool MPGeneralConstraintProto::has_abs_constraint() const {
  return _internal_has_abs_constraint();
}
inline void MPGeneralConstraintProto::set_has_abs_constraint() {
  _oneof_case_[0] = kAbsConstraint;
}
inline void MPGeneralConstraintProto::clear_abs_constraint() {
  if (_internal_has_abs_constraint()) {
    if (GetArenaForAllocation() == nullptr) {
      delete general_constraint_.abs_constraint_;
    }
    clear_has_general_constraint();
  }
}
inline ::operations_research::MPAbsConstraint* MPGeneralConstraintProto::release_abs_constraint() {
  // @@protoc_insertion_point(field_release:operations_research.MPGeneralConstraintProto.abs_constraint)
  if (_internal_has_abs_constraint()) {
    clear_has_general_constraint();
      ::operations_research::MPAbsConstraint* temp = general_constraint_.abs_constraint_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    general_constraint_.abs_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::MPAbsConstraint& MPGeneralConstraintProto::_internal_abs_constraint() const {
  return _internal_has_abs_constraint()
      ? *general_constraint_.abs_constraint_
      : reinterpret_cast< ::operations_research::MPAbsConstraint&>(::operations_research::_MPAbsConstraint_default_instance_);
}
inline const ::operations_research::MPAbsConstraint& MPGeneralConstraintProto::abs_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.abs_constraint)
  return _internal_abs_constraint();
}
inline ::operations_research::MPAbsConstraint* MPGeneralConstraintProto::unsafe_arena_release_abs_constraint() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.MPGeneralConstraintProto.abs_constraint)
  if (_internal_has_abs_constraint()) {
    clear_has_general_constraint();
    ::operations_research::MPAbsConstraint* temp = general_constraint_.abs_constraint_;
    general_constraint_.abs_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MPGeneralConstraintProto::unsafe_arena_set_allocated_abs_constraint(::operations_research::MPAbsConstraint* abs_constraint) {
  clear_general_constraint();
  if (abs_constraint) {
    set_has_abs_constraint();
    general_constraint_.abs_constraint_ = abs_constraint;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPGeneralConstraintProto.abs_constraint)
}
inline ::operations_research::MPAbsConstraint* MPGeneralConstraintProto::_internal_mutable_abs_constraint() {
  if (!_internal_has_abs_constraint()) {
    clear_general_constraint();
    set_has_abs_constraint();
    general_constraint_.abs_constraint_ = CreateMaybeMessage< ::operations_research::MPAbsConstraint >(GetArenaForAllocation());
  }
  return general_constraint_.abs_constraint_;
}
inline ::operations_research::MPAbsConstraint* MPGeneralConstraintProto::mutable_abs_constraint() {
  ::operations_research::MPAbsConstraint* _msg = _internal_mutable_abs_constraint();
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.abs_constraint)
  return _msg;
}
 
// .operations_research.MPArrayConstraint and_constraint = 6;
inline bool MPGeneralConstraintProto::_internal_has_and_constraint() const {
  return general_constraint_case() == kAndConstraint;
}
inline bool MPGeneralConstraintProto::has_and_constraint() const {
  return _internal_has_and_constraint();
}
inline void MPGeneralConstraintProto::set_has_and_constraint() {
  _oneof_case_[0] = kAndConstraint;
}
inline void MPGeneralConstraintProto::clear_and_constraint() {
  if (_internal_has_and_constraint()) {
    if (GetArenaForAllocation() == nullptr) {
      delete general_constraint_.and_constraint_;
    }
    clear_has_general_constraint();
  }
}
inline ::operations_research::MPArrayConstraint* MPGeneralConstraintProto::release_and_constraint() {
  // @@protoc_insertion_point(field_release:operations_research.MPGeneralConstraintProto.and_constraint)
  if (_internal_has_and_constraint()) {
    clear_has_general_constraint();
      ::operations_research::MPArrayConstraint* temp = general_constraint_.and_constraint_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    general_constraint_.and_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::MPArrayConstraint& MPGeneralConstraintProto::_internal_and_constraint() const {
  return _internal_has_and_constraint()
      ? *general_constraint_.and_constraint_
      : reinterpret_cast< ::operations_research::MPArrayConstraint&>(::operations_research::_MPArrayConstraint_default_instance_);
}
inline const ::operations_research::MPArrayConstraint& MPGeneralConstraintProto::and_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.and_constraint)
  return _internal_and_constraint();
}
inline ::operations_research::MPArrayConstraint* MPGeneralConstraintProto::unsafe_arena_release_and_constraint() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.MPGeneralConstraintProto.and_constraint)
  if (_internal_has_and_constraint()) {
    clear_has_general_constraint();
    ::operations_research::MPArrayConstraint* temp = general_constraint_.and_constraint_;
    general_constraint_.and_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MPGeneralConstraintProto::unsafe_arena_set_allocated_and_constraint(::operations_research::MPArrayConstraint* and_constraint) {
  clear_general_constraint();
  if (and_constraint) {
    set_has_and_constraint();
    general_constraint_.and_constraint_ = and_constraint;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPGeneralConstraintProto.and_constraint)
}
inline ::operations_research::MPArrayConstraint* MPGeneralConstraintProto::_internal_mutable_and_constraint() {
  if (!_internal_has_and_constraint()) {
    clear_general_constraint();
    set_has_and_constraint();
    general_constraint_.and_constraint_ = CreateMaybeMessage< ::operations_research::MPArrayConstraint >(GetArenaForAllocation());
  }
  return general_constraint_.and_constraint_;
}
inline ::operations_research::MPArrayConstraint* MPGeneralConstraintProto::mutable_and_constraint() {
  ::operations_research::MPArrayConstraint* _msg = _internal_mutable_and_constraint();
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.and_constraint)
  return _msg;
}
 
// .operations_research.MPArrayConstraint or_constraint = 7;
inline bool MPGeneralConstraintProto::_internal_has_or_constraint() const {
  return general_constraint_case() == kOrConstraint;
}
inline bool MPGeneralConstraintProto::has_or_constraint() const {
  return _internal_has_or_constraint();
}
inline void MPGeneralConstraintProto::set_has_or_constraint() {
  _oneof_case_[0] = kOrConstraint;
}
inline void MPGeneralConstraintProto::clear_or_constraint() {
  if (_internal_has_or_constraint()) {
    if (GetArenaForAllocation() == nullptr) {
      delete general_constraint_.or_constraint_;
    }
    clear_has_general_constraint();
  }
}
inline ::operations_research::MPArrayConstraint* MPGeneralConstraintProto::release_or_constraint() {
  // @@protoc_insertion_point(field_release:operations_research.MPGeneralConstraintProto.or_constraint)
  if (_internal_has_or_constraint()) {
    clear_has_general_constraint();
      ::operations_research::MPArrayConstraint* temp = general_constraint_.or_constraint_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    general_constraint_.or_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::MPArrayConstraint& MPGeneralConstraintProto::_internal_or_constraint() const {
  return _internal_has_or_constraint()
      ? *general_constraint_.or_constraint_
      : reinterpret_cast< ::operations_research::MPArrayConstraint&>(::operations_research::_MPArrayConstraint_default_instance_);
}
inline const ::operations_research::MPArrayConstraint& MPGeneralConstraintProto::or_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.or_constraint)
  return _internal_or_constraint();
}
inline ::operations_research::MPArrayConstraint* MPGeneralConstraintProto::unsafe_arena_release_or_constraint() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.MPGeneralConstraintProto.or_constraint)
  if (_internal_has_or_constraint()) {
    clear_has_general_constraint();
    ::operations_research::MPArrayConstraint* temp = general_constraint_.or_constraint_;
    general_constraint_.or_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MPGeneralConstraintProto::unsafe_arena_set_allocated_or_constraint(::operations_research::MPArrayConstraint* or_constraint) {
  clear_general_constraint();
  if (or_constraint) {
    set_has_or_constraint();
    general_constraint_.or_constraint_ = or_constraint;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPGeneralConstraintProto.or_constraint)
}
inline ::operations_research::MPArrayConstraint* MPGeneralConstraintProto::_internal_mutable_or_constraint() {
  if (!_internal_has_or_constraint()) {
    clear_general_constraint();
    set_has_or_constraint();
    general_constraint_.or_constraint_ = CreateMaybeMessage< ::operations_research::MPArrayConstraint >(GetArenaForAllocation());
  }
  return general_constraint_.or_constraint_;
}
inline ::operations_research::MPArrayConstraint* MPGeneralConstraintProto::mutable_or_constraint() {
  ::operations_research::MPArrayConstraint* _msg = _internal_mutable_or_constraint();
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.or_constraint)
  return _msg;
}
 
// .operations_research.MPArrayWithConstantConstraint min_constraint = 8;
inline bool MPGeneralConstraintProto::_internal_has_min_constraint() const {
  return general_constraint_case() == kMinConstraint;
}
inline bool MPGeneralConstraintProto::has_min_constraint() const {
  return _internal_has_min_constraint();
}
inline void MPGeneralConstraintProto::set_has_min_constraint() {
  _oneof_case_[0] = kMinConstraint;
}
inline void MPGeneralConstraintProto::clear_min_constraint() {
  if (_internal_has_min_constraint()) {
    if (GetArenaForAllocation() == nullptr) {
      delete general_constraint_.min_constraint_;
    }
    clear_has_general_constraint();
  }
}
inline ::operations_research::MPArrayWithConstantConstraint* MPGeneralConstraintProto::release_min_constraint() {
  // @@protoc_insertion_point(field_release:operations_research.MPGeneralConstraintProto.min_constraint)
  if (_internal_has_min_constraint()) {
    clear_has_general_constraint();
      ::operations_research::MPArrayWithConstantConstraint* temp = general_constraint_.min_constraint_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    general_constraint_.min_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::MPArrayWithConstantConstraint& MPGeneralConstraintProto::_internal_min_constraint() const {
  return _internal_has_min_constraint()
      ? *general_constraint_.min_constraint_
      : reinterpret_cast< ::operations_research::MPArrayWithConstantConstraint&>(::operations_research::_MPArrayWithConstantConstraint_default_instance_);
}
inline const ::operations_research::MPArrayWithConstantConstraint& MPGeneralConstraintProto::min_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.min_constraint)
  return _internal_min_constraint();
}
inline ::operations_research::MPArrayWithConstantConstraint* MPGeneralConstraintProto::unsafe_arena_release_min_constraint() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.MPGeneralConstraintProto.min_constraint)
  if (_internal_has_min_constraint()) {
    clear_has_general_constraint();
    ::operations_research::MPArrayWithConstantConstraint* temp = general_constraint_.min_constraint_;
    general_constraint_.min_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MPGeneralConstraintProto::unsafe_arena_set_allocated_min_constraint(::operations_research::MPArrayWithConstantConstraint* min_constraint) {
  clear_general_constraint();
  if (min_constraint) {
    set_has_min_constraint();
    general_constraint_.min_constraint_ = min_constraint;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPGeneralConstraintProto.min_constraint)
}
inline ::operations_research::MPArrayWithConstantConstraint* MPGeneralConstraintProto::_internal_mutable_min_constraint() {
  if (!_internal_has_min_constraint()) {
    clear_general_constraint();
    set_has_min_constraint();
    general_constraint_.min_constraint_ = CreateMaybeMessage< ::operations_research::MPArrayWithConstantConstraint >(GetArenaForAllocation());
  }
  return general_constraint_.min_constraint_;
}
inline ::operations_research::MPArrayWithConstantConstraint* MPGeneralConstraintProto::mutable_min_constraint() {
  ::operations_research::MPArrayWithConstantConstraint* _msg = _internal_mutable_min_constraint();
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.min_constraint)
  return _msg;
}
 
// .operations_research.MPArrayWithConstantConstraint max_constraint = 9;
inline bool MPGeneralConstraintProto::_internal_has_max_constraint() const {
  return general_constraint_case() == kMaxConstraint;
}
inline bool MPGeneralConstraintProto::has_max_constraint() const {
  return _internal_has_max_constraint();
}
inline void MPGeneralConstraintProto::set_has_max_constraint() {
  _oneof_case_[0] = kMaxConstraint;
}
inline void MPGeneralConstraintProto::clear_max_constraint() {
  if (_internal_has_max_constraint()) {
    if (GetArenaForAllocation() == nullptr) {
      delete general_constraint_.max_constraint_;
    }
    clear_has_general_constraint();
  }
}
inline ::operations_research::MPArrayWithConstantConstraint* MPGeneralConstraintProto::release_max_constraint() {
  // @@protoc_insertion_point(field_release:operations_research.MPGeneralConstraintProto.max_constraint)
  if (_internal_has_max_constraint()) {
    clear_has_general_constraint();
      ::operations_research::MPArrayWithConstantConstraint* temp = general_constraint_.max_constraint_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    general_constraint_.max_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::MPArrayWithConstantConstraint& MPGeneralConstraintProto::_internal_max_constraint() const {
  return _internal_has_max_constraint()
      ? *general_constraint_.max_constraint_
      : reinterpret_cast< ::operations_research::MPArrayWithConstantConstraint&>(::operations_research::_MPArrayWithConstantConstraint_default_instance_);
}
inline const ::operations_research::MPArrayWithConstantConstraint& MPGeneralConstraintProto::max_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.max_constraint)
  return _internal_max_constraint();
}
inline ::operations_research::MPArrayWithConstantConstraint* MPGeneralConstraintProto::unsafe_arena_release_max_constraint() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.MPGeneralConstraintProto.max_constraint)
  if (_internal_has_max_constraint()) {
    clear_has_general_constraint();
    ::operations_research::MPArrayWithConstantConstraint* temp = general_constraint_.max_constraint_;
    general_constraint_.max_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MPGeneralConstraintProto::unsafe_arena_set_allocated_max_constraint(::operations_research::MPArrayWithConstantConstraint* max_constraint) {
  clear_general_constraint();
  if (max_constraint) {
    set_has_max_constraint();
    general_constraint_.max_constraint_ = max_constraint;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPGeneralConstraintProto.max_constraint)
}
inline ::operations_research::MPArrayWithConstantConstraint* MPGeneralConstraintProto::_internal_mutable_max_constraint() {
  if (!_internal_has_max_constraint()) {
    clear_general_constraint();
    set_has_max_constraint();
    general_constraint_.max_constraint_ = CreateMaybeMessage< ::operations_research::MPArrayWithConstantConstraint >(GetArenaForAllocation());
  }
  return general_constraint_.max_constraint_;
}
inline ::operations_research::MPArrayWithConstantConstraint* MPGeneralConstraintProto::mutable_max_constraint() {
  ::operations_research::MPArrayWithConstantConstraint* _msg = _internal_mutable_max_constraint();
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.max_constraint)
  return _msg;
}
 
inline bool MPGeneralConstraintProto::has_general_constraint() const {
  return general_constraint_case() != GENERAL_CONSTRAINT_NOT_SET;
}
inline void MPGeneralConstraintProto::clear_has_general_constraint() {
  _oneof_case_[0] = GENERAL_CONSTRAINT_NOT_SET;
}
inline MPGeneralConstraintProto::GeneralConstraintCase MPGeneralConstraintProto::general_constraint_case() const {
  return MPGeneralConstraintProto::GeneralConstraintCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
 
// MPIndicatorConstraint
 
// optional int32 var_index = 1;
inline bool MPIndicatorConstraint::_internal_has_var_index() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MPIndicatorConstraint::has_var_index() const {
  return _internal_has_var_index();
}
inline void MPIndicatorConstraint::clear_var_index() {
  var_index_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline int32_t MPIndicatorConstraint::_internal_var_index() const {
  return var_index_;
}
inline int32_t MPIndicatorConstraint::var_index() const {
  // @@protoc_insertion_point(field_get:operations_research.MPIndicatorConstraint.var_index)
  return _internal_var_index();
}
inline void MPIndicatorConstraint::_internal_set_var_index(int32_t value) {
  _has_bits_[0] |= 0x00000002u;
  var_index_ = value;
}
inline void MPIndicatorConstraint::set_var_index(int32_t value) {
  _internal_set_var_index(value);
  // @@protoc_insertion_point(field_set:operations_research.MPIndicatorConstraint.var_index)
}
 
// optional int32 var_value = 2;
inline bool MPIndicatorConstraint::_internal_has_var_value() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MPIndicatorConstraint::has_var_value() const {
  return _internal_has_var_value();
}
inline void MPIndicatorConstraint::clear_var_value() {
  var_value_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline int32_t MPIndicatorConstraint::_internal_var_value() const {
  return var_value_;
}
inline int32_t MPIndicatorConstraint::var_value() const {
  // @@protoc_insertion_point(field_get:operations_research.MPIndicatorConstraint.var_value)
  return _internal_var_value();
}
inline void MPIndicatorConstraint::_internal_set_var_value(int32_t value) {
  _has_bits_[0] |= 0x00000004u;
  var_value_ = value;
}
inline void MPIndicatorConstraint::set_var_value(int32_t value) {
  _internal_set_var_value(value);
  // @@protoc_insertion_point(field_set:operations_research.MPIndicatorConstraint.var_value)
}
 
// optional .operations_research.MPConstraintProto constraint = 3;
inline bool MPIndicatorConstraint::_internal_has_constraint() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || constraint_ != nullptr);
  return value;
}
inline bool MPIndicatorConstraint::has_constraint() const {
  return _internal_has_constraint();
}
inline void MPIndicatorConstraint::clear_constraint() {
  if (constraint_ != nullptr) constraint_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::operations_research::MPConstraintProto& MPIndicatorConstraint::_internal_constraint() const {
  const ::operations_research::MPConstraintProto* p = constraint_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::MPConstraintProto&>(
      ::operations_research::_MPConstraintProto_default_instance_);
}
inline const ::operations_research::MPConstraintProto& MPIndicatorConstraint::constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPIndicatorConstraint.constraint)
  return _internal_constraint();
}
inline void MPIndicatorConstraint::unsafe_arena_set_allocated_constraint(
    ::operations_research::MPConstraintProto* constraint) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(constraint_);
  }
  constraint_ = constraint;
  if (constraint) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPIndicatorConstraint.constraint)
}
inline ::operations_research::MPConstraintProto* MPIndicatorConstraint::release_constraint() {
  _has_bits_[0] &= ~0x00000001u;
  ::operations_research::MPConstraintProto* temp = constraint_;
  constraint_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::MPConstraintProto* MPIndicatorConstraint::unsafe_arena_release_constraint() {
  // @@protoc_insertion_point(field_release:operations_research.MPIndicatorConstraint.constraint)
  _has_bits_[0] &= ~0x00000001u;
  ::operations_research::MPConstraintProto* temp = constraint_;
  constraint_ = nullptr;
  return temp;
}
inline ::operations_research::MPConstraintProto* MPIndicatorConstraint::_internal_mutable_constraint() {
  _has_bits_[0] |= 0x00000001u;
  if (constraint_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::MPConstraintProto>(GetArenaForAllocation());
    constraint_ = p;
  }
  return constraint_;
}
inline ::operations_research::MPConstraintProto* MPIndicatorConstraint::mutable_constraint() {
  ::operations_research::MPConstraintProto* _msg = _internal_mutable_constraint();
  // @@protoc_insertion_point(field_mutable:operations_research.MPIndicatorConstraint.constraint)
  return _msg;
}
inline void MPIndicatorConstraint::set_allocated_constraint(::operations_research::MPConstraintProto* constraint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete constraint_;
  }
  if (constraint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPConstraintProto>::GetOwningArena(constraint);
    if (message_arena != submessage_arena) {
      constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, constraint, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  constraint_ = constraint;
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPIndicatorConstraint.constraint)
}
 
// -------------------------------------------------------------------
 
// MPSosConstraint
 
// optional .operations_research.MPSosConstraint.Type type = 1 [default = SOS1_DEFAULT];
inline bool MPSosConstraint::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPSosConstraint::has_type() const {
  return _internal_has_type();
}
inline void MPSosConstraint::clear_type() {
  type_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::operations_research::MPSosConstraint_Type MPSosConstraint::_internal_type() const {
  return static_cast< ::operations_research::MPSosConstraint_Type >(type_);
}
inline ::operations_research::MPSosConstraint_Type MPSosConstraint::type() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSosConstraint.type)
  return _internal_type();
}
inline void MPSosConstraint::_internal_set_type(::operations_research::MPSosConstraint_Type value) {
  assert(::operations_research::MPSosConstraint_Type_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  type_ = value;
}
inline void MPSosConstraint::set_type(::operations_research::MPSosConstraint_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:operations_research.MPSosConstraint.type)
}
 
// repeated int32 var_index = 2;
inline int MPSosConstraint::_internal_var_index_size() const {
  return var_index_.size();
}
inline int MPSosConstraint::var_index_size() const {
  return _internal_var_index_size();
}
inline void MPSosConstraint::clear_var_index() {
  var_index_.Clear();
}
inline int32_t MPSosConstraint::_internal_var_index(int index) const {
  return var_index_.Get(index);
}
inline int32_t MPSosConstraint::var_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSosConstraint.var_index)
  return _internal_var_index(index);
}
inline void MPSosConstraint::set_var_index(int index, int32_t value) {
  var_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPSosConstraint.var_index)
}
inline void MPSosConstraint::_internal_add_var_index(int32_t value) {
  var_index_.Add(value);
}
inline void MPSosConstraint::add_var_index(int32_t value) {
  _internal_add_var_index(value);
  // @@protoc_insertion_point(field_add:operations_research.MPSosConstraint.var_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPSosConstraint::_internal_var_index() const {
  return var_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPSosConstraint::var_index() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSosConstraint.var_index)
  return _internal_var_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPSosConstraint::_internal_mutable_var_index() {
  return &var_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPSosConstraint::mutable_var_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPSosConstraint.var_index)
  return _internal_mutable_var_index();
}
 
// repeated double weight = 3;
inline int MPSosConstraint::_internal_weight_size() const {
  return weight_.size();
}
inline int MPSosConstraint::weight_size() const {
  return _internal_weight_size();
}
inline void MPSosConstraint::clear_weight() {
  weight_.Clear();
}
inline double MPSosConstraint::_internal_weight(int index) const {
  return weight_.Get(index);
}
inline double MPSosConstraint::weight(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSosConstraint.weight)
  return _internal_weight(index);
}
inline void MPSosConstraint::set_weight(int index, double value) {
  weight_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPSosConstraint.weight)
}
inline void MPSosConstraint::_internal_add_weight(double value) {
  weight_.Add(value);
}
inline void MPSosConstraint::add_weight(double value) {
  _internal_add_weight(value);
  // @@protoc_insertion_point(field_add:operations_research.MPSosConstraint.weight)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSosConstraint::_internal_weight() const {
  return weight_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSosConstraint::weight() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSosConstraint.weight)
  return _internal_weight();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPSosConstraint::_internal_mutable_weight() {
  return &weight_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPSosConstraint::mutable_weight() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPSosConstraint.weight)
  return _internal_mutable_weight();
}
 
// -------------------------------------------------------------------
 
// MPQuadraticConstraint
 
// repeated int32 var_index = 1;
inline int MPQuadraticConstraint::_internal_var_index_size() const {
  return var_index_.size();
}
inline int MPQuadraticConstraint::var_index_size() const {
  return _internal_var_index_size();
}
inline void MPQuadraticConstraint::clear_var_index() {
  var_index_.Clear();
}
inline int32_t MPQuadraticConstraint::_internal_var_index(int index) const {
  return var_index_.Get(index);
}
inline int32_t MPQuadraticConstraint::var_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPQuadraticConstraint.var_index)
  return _internal_var_index(index);
}
inline void MPQuadraticConstraint::set_var_index(int index, int32_t value) {
  var_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPQuadraticConstraint.var_index)
}
inline void MPQuadraticConstraint::_internal_add_var_index(int32_t value) {
  var_index_.Add(value);
}
inline void MPQuadraticConstraint::add_var_index(int32_t value) {
  _internal_add_var_index(value);
  // @@protoc_insertion_point(field_add:operations_research.MPQuadraticConstraint.var_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPQuadraticConstraint::_internal_var_index() const {
  return var_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPQuadraticConstraint::var_index() const {
  // @@protoc_insertion_point(field_list:operations_research.MPQuadraticConstraint.var_index)
  return _internal_var_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPQuadraticConstraint::_internal_mutable_var_index() {
  return &var_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPQuadraticConstraint::mutable_var_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPQuadraticConstraint.var_index)
  return _internal_mutable_var_index();
}
 
// repeated double coefficient = 2;
inline int MPQuadraticConstraint::_internal_coefficient_size() const {
  return coefficient_.size();
}
inline int MPQuadraticConstraint::coefficient_size() const {
  return _internal_coefficient_size();
}
inline void MPQuadraticConstraint::clear_coefficient() {
  coefficient_.Clear();
}
inline double MPQuadraticConstraint::_internal_coefficient(int index) const {
  return coefficient_.Get(index);
}
inline double MPQuadraticConstraint::coefficient(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPQuadraticConstraint.coefficient)
  return _internal_coefficient(index);
}
inline void MPQuadraticConstraint::set_coefficient(int index, double value) {
  coefficient_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPQuadraticConstraint.coefficient)
}
inline void MPQuadraticConstraint::_internal_add_coefficient(double value) {
  coefficient_.Add(value);
}
inline void MPQuadraticConstraint::add_coefficient(double value) {
  _internal_add_coefficient(value);
  // @@protoc_insertion_point(field_add:operations_research.MPQuadraticConstraint.coefficient)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPQuadraticConstraint::_internal_coefficient() const {
  return coefficient_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPQuadraticConstraint::coefficient() const {
  // @@protoc_insertion_point(field_list:operations_research.MPQuadraticConstraint.coefficient)
  return _internal_coefficient();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPQuadraticConstraint::_internal_mutable_coefficient() {
  return &coefficient_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPQuadraticConstraint::mutable_coefficient() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPQuadraticConstraint.coefficient)
  return _internal_mutable_coefficient();
}
 
// repeated int32 qvar1_index = 3;
inline int MPQuadraticConstraint::_internal_qvar1_index_size() const {
  return qvar1_index_.size();
}
inline int MPQuadraticConstraint::qvar1_index_size() const {
  return _internal_qvar1_index_size();
}
inline void MPQuadraticConstraint::clear_qvar1_index() {
  qvar1_index_.Clear();
}
inline int32_t MPQuadraticConstraint::_internal_qvar1_index(int index) const {
  return qvar1_index_.Get(index);
}
inline int32_t MPQuadraticConstraint::qvar1_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPQuadraticConstraint.qvar1_index)
  return _internal_qvar1_index(index);
}
inline void MPQuadraticConstraint::set_qvar1_index(int index, int32_t value) {
  qvar1_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPQuadraticConstraint.qvar1_index)
}
inline void MPQuadraticConstraint::_internal_add_qvar1_index(int32_t value) {
  qvar1_index_.Add(value);
}
inline void MPQuadraticConstraint::add_qvar1_index(int32_t value) {
  _internal_add_qvar1_index(value);
  // @@protoc_insertion_point(field_add:operations_research.MPQuadraticConstraint.qvar1_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPQuadraticConstraint::_internal_qvar1_index() const {
  return qvar1_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPQuadraticConstraint::qvar1_index() const {
  // @@protoc_insertion_point(field_list:operations_research.MPQuadraticConstraint.qvar1_index)
  return _internal_qvar1_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPQuadraticConstraint::_internal_mutable_qvar1_index() {
  return &qvar1_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPQuadraticConstraint::mutable_qvar1_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPQuadraticConstraint.qvar1_index)
  return _internal_mutable_qvar1_index();
}
 
// repeated int32 qvar2_index = 4;
inline int MPQuadraticConstraint::_internal_qvar2_index_size() const {
  return qvar2_index_.size();
}
inline int MPQuadraticConstraint::qvar2_index_size() const {
  return _internal_qvar2_index_size();
}
inline void MPQuadraticConstraint::clear_qvar2_index() {
  qvar2_index_.Clear();
}
inline int32_t MPQuadraticConstraint::_internal_qvar2_index(int index) const {
  return qvar2_index_.Get(index);
}
inline int32_t MPQuadraticConstraint::qvar2_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPQuadraticConstraint.qvar2_index)
  return _internal_qvar2_index(index);
}
inline void MPQuadraticConstraint::set_qvar2_index(int index, int32_t value) {
  qvar2_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPQuadraticConstraint.qvar2_index)
}
inline void MPQuadraticConstraint::_internal_add_qvar2_index(int32_t value) {
  qvar2_index_.Add(value);
}
inline void MPQuadraticConstraint::add_qvar2_index(int32_t value) {
  _internal_add_qvar2_index(value);
  // @@protoc_insertion_point(field_add:operations_research.MPQuadraticConstraint.qvar2_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPQuadraticConstraint::_internal_qvar2_index() const {
  return qvar2_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPQuadraticConstraint::qvar2_index() const {
  // @@protoc_insertion_point(field_list:operations_research.MPQuadraticConstraint.qvar2_index)
  return _internal_qvar2_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPQuadraticConstraint::_internal_mutable_qvar2_index() {
  return &qvar2_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPQuadraticConstraint::mutable_qvar2_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPQuadraticConstraint.qvar2_index)
  return _internal_mutable_qvar2_index();
}
 
// repeated double qcoefficient = 5;
inline int MPQuadraticConstraint::_internal_qcoefficient_size() const {
  return qcoefficient_.size();
}
inline int MPQuadraticConstraint::qcoefficient_size() const {
  return _internal_qcoefficient_size();
}
inline void MPQuadraticConstraint::clear_qcoefficient() {
  qcoefficient_.Clear();
}
inline double MPQuadraticConstraint::_internal_qcoefficient(int index) const {
  return qcoefficient_.Get(index);
}
inline double MPQuadraticConstraint::qcoefficient(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPQuadraticConstraint.qcoefficient)
  return _internal_qcoefficient(index);
}
inline void MPQuadraticConstraint::set_qcoefficient(int index, double value) {
  qcoefficient_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPQuadraticConstraint.qcoefficient)
}
inline void MPQuadraticConstraint::_internal_add_qcoefficient(double value) {
  qcoefficient_.Add(value);
}
inline void MPQuadraticConstraint::add_qcoefficient(double value) {
  _internal_add_qcoefficient(value);
  // @@protoc_insertion_point(field_add:operations_research.MPQuadraticConstraint.qcoefficient)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPQuadraticConstraint::_internal_qcoefficient() const {
  return qcoefficient_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPQuadraticConstraint::qcoefficient() const {
  // @@protoc_insertion_point(field_list:operations_research.MPQuadraticConstraint.qcoefficient)
  return _internal_qcoefficient();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPQuadraticConstraint::_internal_mutable_qcoefficient() {
  return &qcoefficient_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPQuadraticConstraint::mutable_qcoefficient() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPQuadraticConstraint.qcoefficient)
  return _internal_mutable_qcoefficient();
}
 
// optional double lower_bound = 6 [default = -inf];
inline bool MPQuadraticConstraint::_internal_has_lower_bound() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPQuadraticConstraint::has_lower_bound() const {
  return _internal_has_lower_bound();
}
inline void MPQuadraticConstraint::clear_lower_bound() {
  lower_bound_ = -std::numeric_limits<double>::infinity();
  _has_bits_[0] &= ~0x00000001u;
}
inline double MPQuadraticConstraint::_internal_lower_bound() const {
  return lower_bound_;
}
inline double MPQuadraticConstraint::lower_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPQuadraticConstraint.lower_bound)
  return _internal_lower_bound();
}
inline void MPQuadraticConstraint::_internal_set_lower_bound(double value) {
  _has_bits_[0] |= 0x00000001u;
  lower_bound_ = value;
}
inline void MPQuadraticConstraint::set_lower_bound(double value) {
  _internal_set_lower_bound(value);
  // @@protoc_insertion_point(field_set:operations_research.MPQuadraticConstraint.lower_bound)
}
 
// optional double upper_bound = 7 [default = inf];
inline bool MPQuadraticConstraint::_internal_has_upper_bound() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MPQuadraticConstraint::has_upper_bound() const {
  return _internal_has_upper_bound();
}
inline void MPQuadraticConstraint::clear_upper_bound() {
  upper_bound_ = std::numeric_limits<double>::infinity();
  _has_bits_[0] &= ~0x00000002u;
}
inline double MPQuadraticConstraint::_internal_upper_bound() const {
  return upper_bound_;
}
inline double MPQuadraticConstraint::upper_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPQuadraticConstraint.upper_bound)
  return _internal_upper_bound();
}
inline void MPQuadraticConstraint::_internal_set_upper_bound(double value) {
  _has_bits_[0] |= 0x00000002u;
  upper_bound_ = value;
}
inline void MPQuadraticConstraint::set_upper_bound(double value) {
  _internal_set_upper_bound(value);
  // @@protoc_insertion_point(field_set:operations_research.MPQuadraticConstraint.upper_bound)
}
 
// -------------------------------------------------------------------
 
// MPAbsConstraint
 
// optional int32 var_index = 1;
inline bool MPAbsConstraint::_internal_has_var_index() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPAbsConstraint::has_var_index() const {
  return _internal_has_var_index();
}
inline void MPAbsConstraint::clear_var_index() {
  var_index_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline int32_t MPAbsConstraint::_internal_var_index() const {
  return var_index_;
}
inline int32_t MPAbsConstraint::var_index() const {
  // @@protoc_insertion_point(field_get:operations_research.MPAbsConstraint.var_index)
  return _internal_var_index();
}
inline void MPAbsConstraint::_internal_set_var_index(int32_t value) {
  _has_bits_[0] |= 0x00000001u;
  var_index_ = value;
}
inline void MPAbsConstraint::set_var_index(int32_t value) {
  _internal_set_var_index(value);
  // @@protoc_insertion_point(field_set:operations_research.MPAbsConstraint.var_index)
}
 
// optional int32 resultant_var_index = 2;
inline bool MPAbsConstraint::_internal_has_resultant_var_index() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MPAbsConstraint::has_resultant_var_index() const {
  return _internal_has_resultant_var_index();
}
inline void MPAbsConstraint::clear_resultant_var_index() {
  resultant_var_index_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline int32_t MPAbsConstraint::_internal_resultant_var_index() const {
  return resultant_var_index_;
}
inline int32_t MPAbsConstraint::resultant_var_index() const {
  // @@protoc_insertion_point(field_get:operations_research.MPAbsConstraint.resultant_var_index)
  return _internal_resultant_var_index();
}
inline void MPAbsConstraint::_internal_set_resultant_var_index(int32_t value) {
  _has_bits_[0] |= 0x00000002u;
  resultant_var_index_ = value;
}
inline void MPAbsConstraint::set_resultant_var_index(int32_t value) {
  _internal_set_resultant_var_index(value);
  // @@protoc_insertion_point(field_set:operations_research.MPAbsConstraint.resultant_var_index)
}
 
// -------------------------------------------------------------------
 
// MPArrayConstraint
 
// repeated int32 var_index = 1;
inline int MPArrayConstraint::_internal_var_index_size() const {
  return var_index_.size();
}
inline int MPArrayConstraint::var_index_size() const {
  return _internal_var_index_size();
}
inline void MPArrayConstraint::clear_var_index() {
  var_index_.Clear();
}
inline int32_t MPArrayConstraint::_internal_var_index(int index) const {
  return var_index_.Get(index);
}
inline int32_t MPArrayConstraint::var_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPArrayConstraint.var_index)
  return _internal_var_index(index);
}
inline void MPArrayConstraint::set_var_index(int index, int32_t value) {
  var_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPArrayConstraint.var_index)
}
inline void MPArrayConstraint::_internal_add_var_index(int32_t value) {
  var_index_.Add(value);
}
inline void MPArrayConstraint::add_var_index(int32_t value) {
  _internal_add_var_index(value);
  // @@protoc_insertion_point(field_add:operations_research.MPArrayConstraint.var_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPArrayConstraint::_internal_var_index() const {
  return var_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPArrayConstraint::var_index() const {
  // @@protoc_insertion_point(field_list:operations_research.MPArrayConstraint.var_index)
  return _internal_var_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPArrayConstraint::_internal_mutable_var_index() {
  return &var_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPArrayConstraint::mutable_var_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPArrayConstraint.var_index)
  return _internal_mutable_var_index();
}
 
// optional int32 resultant_var_index = 2;
inline bool MPArrayConstraint::_internal_has_resultant_var_index() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPArrayConstraint::has_resultant_var_index() const {
  return _internal_has_resultant_var_index();
}
inline void MPArrayConstraint::clear_resultant_var_index() {
  resultant_var_index_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline int32_t MPArrayConstraint::_internal_resultant_var_index() const {
  return resultant_var_index_;
}
inline int32_t MPArrayConstraint::resultant_var_index() const {
  // @@protoc_insertion_point(field_get:operations_research.MPArrayConstraint.resultant_var_index)
  return _internal_resultant_var_index();
}
inline void MPArrayConstraint::_internal_set_resultant_var_index(int32_t value) {
  _has_bits_[0] |= 0x00000001u;
  resultant_var_index_ = value;
}
inline void MPArrayConstraint::set_resultant_var_index(int32_t value) {
  _internal_set_resultant_var_index(value);
  // @@protoc_insertion_point(field_set:operations_research.MPArrayConstraint.resultant_var_index)
}
 
// -------------------------------------------------------------------
 
// MPArrayWithConstantConstraint
 
// repeated int32 var_index = 1;
inline int MPArrayWithConstantConstraint::_internal_var_index_size() const {
  return var_index_.size();
}
inline int MPArrayWithConstantConstraint::var_index_size() const {
  return _internal_var_index_size();
}
inline void MPArrayWithConstantConstraint::clear_var_index() {
  var_index_.Clear();
}
inline int32_t MPArrayWithConstantConstraint::_internal_var_index(int index) const {
  return var_index_.Get(index);
}
inline int32_t MPArrayWithConstantConstraint::var_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPArrayWithConstantConstraint.var_index)
  return _internal_var_index(index);
}
inline void MPArrayWithConstantConstraint::set_var_index(int index, int32_t value) {
  var_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPArrayWithConstantConstraint.var_index)
}
inline void MPArrayWithConstantConstraint::_internal_add_var_index(int32_t value) {
  var_index_.Add(value);
}
inline void MPArrayWithConstantConstraint::add_var_index(int32_t value) {
  _internal_add_var_index(value);
  // @@protoc_insertion_point(field_add:operations_research.MPArrayWithConstantConstraint.var_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPArrayWithConstantConstraint::_internal_var_index() const {
  return var_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPArrayWithConstantConstraint::var_index() const {
  // @@protoc_insertion_point(field_list:operations_research.MPArrayWithConstantConstraint.var_index)
  return _internal_var_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPArrayWithConstantConstraint::_internal_mutable_var_index() {
  return &var_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPArrayWithConstantConstraint::mutable_var_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPArrayWithConstantConstraint.var_index)
  return _internal_mutable_var_index();
}
 
// optional double constant = 2;
inline bool MPArrayWithConstantConstraint::_internal_has_constant() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPArrayWithConstantConstraint::has_constant() const {
  return _internal_has_constant();
}
inline void MPArrayWithConstantConstraint::clear_constant() {
  constant_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline double MPArrayWithConstantConstraint::_internal_constant() const {
  return constant_;
}
inline double MPArrayWithConstantConstraint::constant() const {
  // @@protoc_insertion_point(field_get:operations_research.MPArrayWithConstantConstraint.constant)
  return _internal_constant();
}
inline void MPArrayWithConstantConstraint::_internal_set_constant(double value) {
  _has_bits_[0] |= 0x00000001u;
  constant_ = value;
}
inline void MPArrayWithConstantConstraint::set_constant(double value) {
  _internal_set_constant(value);
  // @@protoc_insertion_point(field_set:operations_research.MPArrayWithConstantConstraint.constant)
}
 
// optional int32 resultant_var_index = 3;
inline bool MPArrayWithConstantConstraint::_internal_has_resultant_var_index() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MPArrayWithConstantConstraint::has_resultant_var_index() const {
  return _internal_has_resultant_var_index();
}
inline void MPArrayWithConstantConstraint::clear_resultant_var_index() {
  resultant_var_index_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline int32_t MPArrayWithConstantConstraint::_internal_resultant_var_index() const {
  return resultant_var_index_;
}
inline int32_t MPArrayWithConstantConstraint::resultant_var_index() const {
  // @@protoc_insertion_point(field_get:operations_research.MPArrayWithConstantConstraint.resultant_var_index)
  return _internal_resultant_var_index();
}
inline void MPArrayWithConstantConstraint::_internal_set_resultant_var_index(int32_t value) {
  _has_bits_[0] |= 0x00000002u;
  resultant_var_index_ = value;
}
inline void MPArrayWithConstantConstraint::set_resultant_var_index(int32_t value) {
  _internal_set_resultant_var_index(value);
  // @@protoc_insertion_point(field_set:operations_research.MPArrayWithConstantConstraint.resultant_var_index)
}
 
// -------------------------------------------------------------------
 
// MPQuadraticObjective
 
// repeated int32 qvar1_index = 1;
inline int MPQuadraticObjective::_internal_qvar1_index_size() const {
  return qvar1_index_.size();
}
inline int MPQuadraticObjective::qvar1_index_size() const {
  return _internal_qvar1_index_size();
}
inline void MPQuadraticObjective::clear_qvar1_index() {
  qvar1_index_.Clear();
}
inline int32_t MPQuadraticObjective::_internal_qvar1_index(int index) const {
  return qvar1_index_.Get(index);
}
inline int32_t MPQuadraticObjective::qvar1_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPQuadraticObjective.qvar1_index)
  return _internal_qvar1_index(index);
}
inline void MPQuadraticObjective::set_qvar1_index(int index, int32_t value) {
  qvar1_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPQuadraticObjective.qvar1_index)
}
inline void MPQuadraticObjective::_internal_add_qvar1_index(int32_t value) {
  qvar1_index_.Add(value);
}
inline void MPQuadraticObjective::add_qvar1_index(int32_t value) {
  _internal_add_qvar1_index(value);
  // @@protoc_insertion_point(field_add:operations_research.MPQuadraticObjective.qvar1_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPQuadraticObjective::_internal_qvar1_index() const {
  return qvar1_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPQuadraticObjective::qvar1_index() const {
  // @@protoc_insertion_point(field_list:operations_research.MPQuadraticObjective.qvar1_index)
  return _internal_qvar1_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPQuadraticObjective::_internal_mutable_qvar1_index() {
  return &qvar1_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPQuadraticObjective::mutable_qvar1_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPQuadraticObjective.qvar1_index)
  return _internal_mutable_qvar1_index();
}
 
// repeated int32 qvar2_index = 2;
inline int MPQuadraticObjective::_internal_qvar2_index_size() const {
  return qvar2_index_.size();
}
inline int MPQuadraticObjective::qvar2_index_size() const {
  return _internal_qvar2_index_size();
}
inline void MPQuadraticObjective::clear_qvar2_index() {
  qvar2_index_.Clear();
}
inline int32_t MPQuadraticObjective::_internal_qvar2_index(int index) const {
  return qvar2_index_.Get(index);
}
inline int32_t MPQuadraticObjective::qvar2_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPQuadraticObjective.qvar2_index)
  return _internal_qvar2_index(index);
}
inline void MPQuadraticObjective::set_qvar2_index(int index, int32_t value) {
  qvar2_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPQuadraticObjective.qvar2_index)
}
inline void MPQuadraticObjective::_internal_add_qvar2_index(int32_t value) {
  qvar2_index_.Add(value);
}
inline void MPQuadraticObjective::add_qvar2_index(int32_t value) {
  _internal_add_qvar2_index(value);
  // @@protoc_insertion_point(field_add:operations_research.MPQuadraticObjective.qvar2_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPQuadraticObjective::_internal_qvar2_index() const {
  return qvar2_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
MPQuadraticObjective::qvar2_index() const {
  // @@protoc_insertion_point(field_list:operations_research.MPQuadraticObjective.qvar2_index)
  return _internal_qvar2_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPQuadraticObjective::_internal_mutable_qvar2_index() {
  return &qvar2_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
MPQuadraticObjective::mutable_qvar2_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPQuadraticObjective.qvar2_index)
  return _internal_mutable_qvar2_index();
}
 
// repeated double coefficient = 3;
inline int MPQuadraticObjective::_internal_coefficient_size() const {
  return coefficient_.size();
}
inline int MPQuadraticObjective::coefficient_size() const {
  return _internal_coefficient_size();
}
inline void MPQuadraticObjective::clear_coefficient() {
  coefficient_.Clear();
}
inline double MPQuadraticObjective::_internal_coefficient(int index) const {
  return coefficient_.Get(index);
}
inline double MPQuadraticObjective::coefficient(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPQuadraticObjective.coefficient)
  return _internal_coefficient(index);
}
inline void MPQuadraticObjective::set_coefficient(int index, double value) {
  coefficient_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPQuadraticObjective.coefficient)
}
inline void MPQuadraticObjective::_internal_add_coefficient(double value) {
  coefficient_.Add(value);
}
inline void MPQuadraticObjective::add_coefficient(double value) {
  _internal_add_coefficient(value);
  // @@protoc_insertion_point(field_add:operations_research.MPQuadraticObjective.coefficient)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPQuadraticObjective::_internal_coefficient() const {
  return coefficient_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPQuadraticObjective::coefficient() const {
  // @@protoc_insertion_point(field_list:operations_research.MPQuadraticObjective.coefficient)
  return _internal_coefficient();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPQuadraticObjective::_internal_mutable_coefficient() {
  return &coefficient_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPQuadraticObjective::mutable_coefficient() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPQuadraticObjective.coefficient)
  return _internal_mutable_coefficient();
}
 
// -------------------------------------------------------------------
 
// PartialVariableAssignment
 
// repeated int32 var_index = 1 [packed = true];
inline int PartialVariableAssignment::_internal_var_index_size() const {
  return var_index_.size();
}
inline int PartialVariableAssignment::var_index_size() const {
  return _internal_var_index_size();
}
inline void PartialVariableAssignment::clear_var_index() {
  var_index_.Clear();
}
inline int32_t PartialVariableAssignment::_internal_var_index(int index) const {
  return var_index_.Get(index);
}
inline int32_t PartialVariableAssignment::var_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.PartialVariableAssignment.var_index)
  return _internal_var_index(index);
}
inline void PartialVariableAssignment::set_var_index(int index, int32_t value) {
  var_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.PartialVariableAssignment.var_index)
}
inline void PartialVariableAssignment::_internal_add_var_index(int32_t value) {
  var_index_.Add(value);
}
inline void PartialVariableAssignment::add_var_index(int32_t value) {
  _internal_add_var_index(value);
  // @@protoc_insertion_point(field_add:operations_research.PartialVariableAssignment.var_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
PartialVariableAssignment::_internal_var_index() const {
  return var_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
PartialVariableAssignment::var_index() const {
  // @@protoc_insertion_point(field_list:operations_research.PartialVariableAssignment.var_index)
  return _internal_var_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
PartialVariableAssignment::_internal_mutable_var_index() {
  return &var_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
PartialVariableAssignment::mutable_var_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.PartialVariableAssignment.var_index)
  return _internal_mutable_var_index();
}
 
// repeated double var_value = 2 [packed = true];
inline int PartialVariableAssignment::_internal_var_value_size() const {
  return var_value_.size();
}
inline int PartialVariableAssignment::var_value_size() const {
  return _internal_var_value_size();
}
inline void PartialVariableAssignment::clear_var_value() {
  var_value_.Clear();
}
inline double PartialVariableAssignment::_internal_var_value(int index) const {
  return var_value_.Get(index);
}
inline double PartialVariableAssignment::var_value(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.PartialVariableAssignment.var_value)
  return _internal_var_value(index);
}
inline void PartialVariableAssignment::set_var_value(int index, double value) {
  var_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.PartialVariableAssignment.var_value)
}
inline void PartialVariableAssignment::_internal_add_var_value(double value) {
  var_value_.Add(value);
}
inline void PartialVariableAssignment::add_var_value(double value) {
  _internal_add_var_value(value);
  // @@protoc_insertion_point(field_add:operations_research.PartialVariableAssignment.var_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
PartialVariableAssignment::_internal_var_value() const {
  return var_value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
PartialVariableAssignment::var_value() const {
  // @@protoc_insertion_point(field_list:operations_research.PartialVariableAssignment.var_value)
  return _internal_var_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
PartialVariableAssignment::_internal_mutable_var_value() {
  return &var_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
PartialVariableAssignment::mutable_var_value() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.PartialVariableAssignment.var_value)
  return _internal_mutable_var_value();
}
 
// -------------------------------------------------------------------
 
// MPModelProto
 
// repeated .operations_research.MPVariableProto variable = 3;
inline int MPModelProto::_internal_variable_size() const {
  return variable_.size();
}
inline int MPModelProto::variable_size() const {
  return _internal_variable_size();
}
inline void MPModelProto::clear_variable() {
  variable_.Clear();
}
inline ::operations_research::MPVariableProto* MPModelProto::mutable_variable(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelProto.variable)
  return variable_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPVariableProto >*
MPModelProto::mutable_variable() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPModelProto.variable)
  return &variable_;
}
inline const ::operations_research::MPVariableProto& MPModelProto::_internal_variable(int index) const {
  return variable_.Get(index);
}
inline const ::operations_research::MPVariableProto& MPModelProto::variable(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.variable)
  return _internal_variable(index);
}
inline ::operations_research::MPVariableProto* MPModelProto::_internal_add_variable() {
  return variable_.Add();
}
inline ::operations_research::MPVariableProto* MPModelProto::add_variable() {
  ::operations_research::MPVariableProto* _add = _internal_add_variable();
  // @@protoc_insertion_point(field_add:operations_research.MPModelProto.variable)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPVariableProto >&
MPModelProto::variable() const {
  // @@protoc_insertion_point(field_list:operations_research.MPModelProto.variable)
  return variable_;
}
 
// repeated .operations_research.MPConstraintProto constraint = 4;
inline int MPModelProto::_internal_constraint_size() const {
  return constraint_.size();
}
inline int MPModelProto::constraint_size() const {
  return _internal_constraint_size();
}
inline void MPModelProto::clear_constraint() {
  constraint_.Clear();
}
inline ::operations_research::MPConstraintProto* MPModelProto::mutable_constraint(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelProto.constraint)
  return constraint_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPConstraintProto >*
MPModelProto::mutable_constraint() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPModelProto.constraint)
  return &constraint_;
}
inline const ::operations_research::MPConstraintProto& MPModelProto::_internal_constraint(int index) const {
  return constraint_.Get(index);
}
inline const ::operations_research::MPConstraintProto& MPModelProto::constraint(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.constraint)
  return _internal_constraint(index);
}
inline ::operations_research::MPConstraintProto* MPModelProto::_internal_add_constraint() {
  return constraint_.Add();
}
inline ::operations_research::MPConstraintProto* MPModelProto::add_constraint() {
  ::operations_research::MPConstraintProto* _add = _internal_add_constraint();
  // @@protoc_insertion_point(field_add:operations_research.MPModelProto.constraint)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPConstraintProto >&
MPModelProto::constraint() const {
  // @@protoc_insertion_point(field_list:operations_research.MPModelProto.constraint)
  return constraint_;
}
 
// repeated .operations_research.MPGeneralConstraintProto general_constraint = 7;
inline int MPModelProto::_internal_general_constraint_size() const {
  return general_constraint_.size();
}
inline int MPModelProto::general_constraint_size() const {
  return _internal_general_constraint_size();
}
inline void MPModelProto::clear_general_constraint() {
  general_constraint_.Clear();
}
inline ::operations_research::MPGeneralConstraintProto* MPModelProto::mutable_general_constraint(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelProto.general_constraint)
  return general_constraint_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPGeneralConstraintProto >*
MPModelProto::mutable_general_constraint() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPModelProto.general_constraint)
  return &general_constraint_;
}
inline const ::operations_research::MPGeneralConstraintProto& MPModelProto::_internal_general_constraint(int index) const {
  return general_constraint_.Get(index);
}
inline const ::operations_research::MPGeneralConstraintProto& MPModelProto::general_constraint(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.general_constraint)
  return _internal_general_constraint(index);
}
inline ::operations_research::MPGeneralConstraintProto* MPModelProto::_internal_add_general_constraint() {
  return general_constraint_.Add();
}
inline ::operations_research::MPGeneralConstraintProto* MPModelProto::add_general_constraint() {
  ::operations_research::MPGeneralConstraintProto* _add = _internal_add_general_constraint();
  // @@protoc_insertion_point(field_add:operations_research.MPModelProto.general_constraint)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPGeneralConstraintProto >&
MPModelProto::general_constraint() const {
  // @@protoc_insertion_point(field_list:operations_research.MPModelProto.general_constraint)
  return general_constraint_;
}
 
// optional bool maximize = 1 [default = false];
inline bool MPModelProto::_internal_has_maximize() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool MPModelProto::has_maximize() const {
  return _internal_has_maximize();
}
inline void MPModelProto::clear_maximize() {
  maximize_ = false;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool MPModelProto::_internal_maximize() const {
  return maximize_;
}
inline bool MPModelProto::maximize() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.maximize)
  return _internal_maximize();
}
inline void MPModelProto::_internal_set_maximize(bool value) {
  _has_bits_[0] |= 0x00000010u;
  maximize_ = value;
}
inline void MPModelProto::set_maximize(bool value) {
  _internal_set_maximize(value);
  // @@protoc_insertion_point(field_set:operations_research.MPModelProto.maximize)
}
 
// optional double objective_offset = 2 [default = 0];
inline bool MPModelProto::_internal_has_objective_offset() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MPModelProto::has_objective_offset() const {
  return _internal_has_objective_offset();
}
inline void MPModelProto::clear_objective_offset() {
  objective_offset_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline double MPModelProto::_internal_objective_offset() const {
  return objective_offset_;
}
inline double MPModelProto::objective_offset() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.objective_offset)
  return _internal_objective_offset();
}
inline void MPModelProto::_internal_set_objective_offset(double value) {
  _has_bits_[0] |= 0x00000008u;
  objective_offset_ = value;
}
inline void MPModelProto::set_objective_offset(double value) {
  _internal_set_objective_offset(value);
  // @@protoc_insertion_point(field_set:operations_research.MPModelProto.objective_offset)
}
 
// optional .operations_research.MPQuadraticObjective quadratic_objective = 8;
inline bool MPModelProto::_internal_has_quadratic_objective() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || quadratic_objective_ != nullptr);
  return value;
}
inline bool MPModelProto::has_quadratic_objective() const {
  return _internal_has_quadratic_objective();
}
inline void MPModelProto::clear_quadratic_objective() {
  if (quadratic_objective_ != nullptr) quadratic_objective_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::operations_research::MPQuadraticObjective& MPModelProto::_internal_quadratic_objective() const {
  const ::operations_research::MPQuadraticObjective* p = quadratic_objective_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::MPQuadraticObjective&>(
      ::operations_research::_MPQuadraticObjective_default_instance_);
}
inline const ::operations_research::MPQuadraticObjective& MPModelProto::quadratic_objective() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.quadratic_objective)
  return _internal_quadratic_objective();
}
inline void MPModelProto::unsafe_arena_set_allocated_quadratic_objective(
    ::operations_research::MPQuadraticObjective* quadratic_objective) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quadratic_objective_);
  }
  quadratic_objective_ = quadratic_objective;
  if (quadratic_objective) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPModelProto.quadratic_objective)
}
inline ::operations_research::MPQuadraticObjective* MPModelProto::release_quadratic_objective() {
  _has_bits_[0] &= ~0x00000004u;
  ::operations_research::MPQuadraticObjective* temp = quadratic_objective_;
  quadratic_objective_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::MPQuadraticObjective* MPModelProto::unsafe_arena_release_quadratic_objective() {
  // @@protoc_insertion_point(field_release:operations_research.MPModelProto.quadratic_objective)
  _has_bits_[0] &= ~0x00000004u;
  ::operations_research::MPQuadraticObjective* temp = quadratic_objective_;
  quadratic_objective_ = nullptr;
  return temp;
}
inline ::operations_research::MPQuadraticObjective* MPModelProto::_internal_mutable_quadratic_objective() {
  _has_bits_[0] |= 0x00000004u;
  if (quadratic_objective_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::MPQuadraticObjective>(GetArenaForAllocation());
    quadratic_objective_ = p;
  }
  return quadratic_objective_;
}
inline ::operations_research::MPQuadraticObjective* MPModelProto::mutable_quadratic_objective() {
  ::operations_research::MPQuadraticObjective* _msg = _internal_mutable_quadratic_objective();
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelProto.quadratic_objective)
  return _msg;
}
inline void MPModelProto::set_allocated_quadratic_objective(::operations_research::MPQuadraticObjective* quadratic_objective) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete quadratic_objective_;
  }
  if (quadratic_objective) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPQuadraticObjective>::GetOwningArena(quadratic_objective);
    if (message_arena != submessage_arena) {
      quadratic_objective = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quadratic_objective, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  quadratic_objective_ = quadratic_objective;
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPModelProto.quadratic_objective)
}
 
// optional string name = 5 [default = ""];
inline bool MPModelProto::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPModelProto::has_name() const {
  return _internal_has_name();
}
inline void MPModelProto::clear_name() {
  name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MPModelProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MPModelProto::set_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.MPModelProto.name)
}
inline std::string* MPModelProto::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelProto.name)
  return _s;
}
inline const std::string& MPModelProto::_internal_name() const {
  return name_.Get();
}
inline void MPModelProto::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* MPModelProto::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* MPModelProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.MPModelProto.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MPModelProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPModelProto.name)
}
 
// optional .operations_research.PartialVariableAssignment solution_hint = 6;
inline bool MPModelProto::_internal_has_solution_hint() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || solution_hint_ != nullptr);
  return value;
}
inline bool MPModelProto::has_solution_hint() const {
  return _internal_has_solution_hint();
}
inline void MPModelProto::clear_solution_hint() {
  if (solution_hint_ != nullptr) solution_hint_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::operations_research::PartialVariableAssignment& MPModelProto::_internal_solution_hint() const {
  const ::operations_research::PartialVariableAssignment* p = solution_hint_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::PartialVariableAssignment&>(
      ::operations_research::_PartialVariableAssignment_default_instance_);
}
inline const ::operations_research::PartialVariableAssignment& MPModelProto::solution_hint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.solution_hint)
  return _internal_solution_hint();
}
inline void MPModelProto::unsafe_arena_set_allocated_solution_hint(
    ::operations_research::PartialVariableAssignment* solution_hint) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(solution_hint_);
  }
  solution_hint_ = solution_hint;
  if (solution_hint) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPModelProto.solution_hint)
}
inline ::operations_research::PartialVariableAssignment* MPModelProto::release_solution_hint() {
  _has_bits_[0] &= ~0x00000002u;
  ::operations_research::PartialVariableAssignment* temp = solution_hint_;
  solution_hint_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::PartialVariableAssignment* MPModelProto::unsafe_arena_release_solution_hint() {
  // @@protoc_insertion_point(field_release:operations_research.MPModelProto.solution_hint)
  _has_bits_[0] &= ~0x00000002u;
  ::operations_research::PartialVariableAssignment* temp = solution_hint_;
  solution_hint_ = nullptr;
  return temp;
}
inline ::operations_research::PartialVariableAssignment* MPModelProto::_internal_mutable_solution_hint() {
  _has_bits_[0] |= 0x00000002u;
  if (solution_hint_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::PartialVariableAssignment>(GetArenaForAllocation());
    solution_hint_ = p;
  }
  return solution_hint_;
}
inline ::operations_research::PartialVariableAssignment* MPModelProto::mutable_solution_hint() {
  ::operations_research::PartialVariableAssignment* _msg = _internal_mutable_solution_hint();
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelProto.solution_hint)
  return _msg;
}
inline void MPModelProto::set_allocated_solution_hint(::operations_research::PartialVariableAssignment* solution_hint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete solution_hint_;
  }
  if (solution_hint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::PartialVariableAssignment>::GetOwningArena(solution_hint);
    if (message_arena != submessage_arena) {
      solution_hint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, solution_hint, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  solution_hint_ = solution_hint;
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPModelProto.solution_hint)
}
 
// -------------------------------------------------------------------
 
// OptionalDouble
 
// optional double value = 1;
inline bool OptionalDouble::_internal_has_value() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool OptionalDouble::has_value() const {
  return _internal_has_value();
}
inline void OptionalDouble::clear_value() {
  value_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline double OptionalDouble::_internal_value() const {
  return value_;
}
inline double OptionalDouble::value() const {
  // @@protoc_insertion_point(field_get:operations_research.OptionalDouble.value)
  return _internal_value();
}
inline void OptionalDouble::_internal_set_value(double value) {
  _has_bits_[0] |= 0x00000001u;
  value_ = value;
}
inline void OptionalDouble::set_value(double value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:operations_research.OptionalDouble.value)
}
 
// -------------------------------------------------------------------
 
// MPSolverCommonParameters
 
// optional .operations_research.OptionalDouble relative_mip_gap = 1;
inline bool MPSolverCommonParameters::_internal_has_relative_mip_gap() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || relative_mip_gap_ != nullptr);
  return value;
}
inline bool MPSolverCommonParameters::has_relative_mip_gap() const {
  return _internal_has_relative_mip_gap();
}
inline void MPSolverCommonParameters::clear_relative_mip_gap() {
  if (relative_mip_gap_ != nullptr) relative_mip_gap_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::operations_research::OptionalDouble& MPSolverCommonParameters::_internal_relative_mip_gap() const {
  const ::operations_research::OptionalDouble* p = relative_mip_gap_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::OptionalDouble&>(
      ::operations_research::_OptionalDouble_default_instance_);
}
inline const ::operations_research::OptionalDouble& MPSolverCommonParameters::relative_mip_gap() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.relative_mip_gap)
  return _internal_relative_mip_gap();
}
inline void MPSolverCommonParameters::unsafe_arena_set_allocated_relative_mip_gap(
    ::operations_research::OptionalDouble* relative_mip_gap) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(relative_mip_gap_);
  }
  relative_mip_gap_ = relative_mip_gap;
  if (relative_mip_gap) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPSolverCommonParameters.relative_mip_gap)
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::release_relative_mip_gap() {
  _has_bits_[0] &= ~0x00000001u;
  ::operations_research::OptionalDouble* temp = relative_mip_gap_;
  relative_mip_gap_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::unsafe_arena_release_relative_mip_gap() {
  // @@protoc_insertion_point(field_release:operations_research.MPSolverCommonParameters.relative_mip_gap)
  _has_bits_[0] &= ~0x00000001u;
  ::operations_research::OptionalDouble* temp = relative_mip_gap_;
  relative_mip_gap_ = nullptr;
  return temp;
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::_internal_mutable_relative_mip_gap() {
  _has_bits_[0] |= 0x00000001u;
  if (relative_mip_gap_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::OptionalDouble>(GetArenaForAllocation());
    relative_mip_gap_ = p;
  }
  return relative_mip_gap_;
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::mutable_relative_mip_gap() {
  ::operations_research::OptionalDouble* _msg = _internal_mutable_relative_mip_gap();
  // @@protoc_insertion_point(field_mutable:operations_research.MPSolverCommonParameters.relative_mip_gap)
  return _msg;
}
inline void MPSolverCommonParameters::set_allocated_relative_mip_gap(::operations_research::OptionalDouble* relative_mip_gap) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete relative_mip_gap_;
  }
  if (relative_mip_gap) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::OptionalDouble>::GetOwningArena(relative_mip_gap);
    if (message_arena != submessage_arena) {
      relative_mip_gap = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relative_mip_gap, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  relative_mip_gap_ = relative_mip_gap;
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPSolverCommonParameters.relative_mip_gap)
}
 
// optional .operations_research.OptionalDouble primal_tolerance = 2;
inline bool MPSolverCommonParameters::_internal_has_primal_tolerance() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || primal_tolerance_ != nullptr);
  return value;
}
inline bool MPSolverCommonParameters::has_primal_tolerance() const {
  return _internal_has_primal_tolerance();
}
inline void MPSolverCommonParameters::clear_primal_tolerance() {
  if (primal_tolerance_ != nullptr) primal_tolerance_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::operations_research::OptionalDouble& MPSolverCommonParameters::_internal_primal_tolerance() const {
  const ::operations_research::OptionalDouble* p = primal_tolerance_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::OptionalDouble&>(
      ::operations_research::_OptionalDouble_default_instance_);
}
inline const ::operations_research::OptionalDouble& MPSolverCommonParameters::primal_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.primal_tolerance)
  return _internal_primal_tolerance();
}
inline void MPSolverCommonParameters::unsafe_arena_set_allocated_primal_tolerance(
    ::operations_research::OptionalDouble* primal_tolerance) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(primal_tolerance_);
  }
  primal_tolerance_ = primal_tolerance;
  if (primal_tolerance) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPSolverCommonParameters.primal_tolerance)
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::release_primal_tolerance() {
  _has_bits_[0] &= ~0x00000002u;
  ::operations_research::OptionalDouble* temp = primal_tolerance_;
  primal_tolerance_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::unsafe_arena_release_primal_tolerance() {
  // @@protoc_insertion_point(field_release:operations_research.MPSolverCommonParameters.primal_tolerance)
  _has_bits_[0] &= ~0x00000002u;
  ::operations_research::OptionalDouble* temp = primal_tolerance_;
  primal_tolerance_ = nullptr;
  return temp;
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::_internal_mutable_primal_tolerance() {
  _has_bits_[0] |= 0x00000002u;
  if (primal_tolerance_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::OptionalDouble>(GetArenaForAllocation());
    primal_tolerance_ = p;
  }
  return primal_tolerance_;
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::mutable_primal_tolerance() {
  ::operations_research::OptionalDouble* _msg = _internal_mutable_primal_tolerance();
  // @@protoc_insertion_point(field_mutable:operations_research.MPSolverCommonParameters.primal_tolerance)
  return _msg;
}
inline void MPSolverCommonParameters::set_allocated_primal_tolerance(::operations_research::OptionalDouble* primal_tolerance) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete primal_tolerance_;
  }
  if (primal_tolerance) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::OptionalDouble>::GetOwningArena(primal_tolerance);
    if (message_arena != submessage_arena) {
      primal_tolerance = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, primal_tolerance, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  primal_tolerance_ = primal_tolerance;
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPSolverCommonParameters.primal_tolerance)
}
 
// optional .operations_research.OptionalDouble dual_tolerance = 3;
inline bool MPSolverCommonParameters::_internal_has_dual_tolerance() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || dual_tolerance_ != nullptr);
  return value;
}
inline bool MPSolverCommonParameters::has_dual_tolerance() const {
  return _internal_has_dual_tolerance();
}
inline void MPSolverCommonParameters::clear_dual_tolerance() {
  if (dual_tolerance_ != nullptr) dual_tolerance_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::operations_research::OptionalDouble& MPSolverCommonParameters::_internal_dual_tolerance() const {
  const ::operations_research::OptionalDouble* p = dual_tolerance_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::OptionalDouble&>(
      ::operations_research::_OptionalDouble_default_instance_);
}
inline const ::operations_research::OptionalDouble& MPSolverCommonParameters::dual_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.dual_tolerance)
  return _internal_dual_tolerance();
}
inline void MPSolverCommonParameters::unsafe_arena_set_allocated_dual_tolerance(
    ::operations_research::OptionalDouble* dual_tolerance) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dual_tolerance_);
  }
  dual_tolerance_ = dual_tolerance;
  if (dual_tolerance) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPSolverCommonParameters.dual_tolerance)
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::release_dual_tolerance() {
  _has_bits_[0] &= ~0x00000004u;
  ::operations_research::OptionalDouble* temp = dual_tolerance_;
  dual_tolerance_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::unsafe_arena_release_dual_tolerance() {
  // @@protoc_insertion_point(field_release:operations_research.MPSolverCommonParameters.dual_tolerance)
  _has_bits_[0] &= ~0x00000004u;
  ::operations_research::OptionalDouble* temp = dual_tolerance_;
  dual_tolerance_ = nullptr;
  return temp;
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::_internal_mutable_dual_tolerance() {
  _has_bits_[0] |= 0x00000004u;
  if (dual_tolerance_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::OptionalDouble>(GetArenaForAllocation());
    dual_tolerance_ = p;
  }
  return dual_tolerance_;
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::mutable_dual_tolerance() {
  ::operations_research::OptionalDouble* _msg = _internal_mutable_dual_tolerance();
  // @@protoc_insertion_point(field_mutable:operations_research.MPSolverCommonParameters.dual_tolerance)
  return _msg;
}
inline void MPSolverCommonParameters::set_allocated_dual_tolerance(::operations_research::OptionalDouble* dual_tolerance) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete dual_tolerance_;
  }
  if (dual_tolerance) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::OptionalDouble>::GetOwningArena(dual_tolerance);
    if (message_arena != submessage_arena) {
      dual_tolerance = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dual_tolerance, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  dual_tolerance_ = dual_tolerance;
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPSolverCommonParameters.dual_tolerance)
}
 
// optional .operations_research.MPSolverCommonParameters.LPAlgorithmValues lp_algorithm = 4 [default = LP_ALGO_UNSPECIFIED];
inline bool MPSolverCommonParameters::_internal_has_lp_algorithm() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MPSolverCommonParameters::has_lp_algorithm() const {
  return _internal_has_lp_algorithm();
}
inline void MPSolverCommonParameters::clear_lp_algorithm() {
  lp_algorithm_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::operations_research::MPSolverCommonParameters_LPAlgorithmValues MPSolverCommonParameters::_internal_lp_algorithm() const {
  return static_cast< ::operations_research::MPSolverCommonParameters_LPAlgorithmValues >(lp_algorithm_);
}
inline ::operations_research::MPSolverCommonParameters_LPAlgorithmValues MPSolverCommonParameters::lp_algorithm() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.lp_algorithm)
  return _internal_lp_algorithm();
}
inline void MPSolverCommonParameters::_internal_set_lp_algorithm(::operations_research::MPSolverCommonParameters_LPAlgorithmValues value) {
  assert(::operations_research::MPSolverCommonParameters_LPAlgorithmValues_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  lp_algorithm_ = value;
}
inline void MPSolverCommonParameters::set_lp_algorithm(::operations_research::MPSolverCommonParameters_LPAlgorithmValues value) {
  _internal_set_lp_algorithm(value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolverCommonParameters.lp_algorithm)
}
 
// optional .operations_research.OptionalBoolean presolve = 5 [default = BOOL_UNSPECIFIED];
inline bool MPSolverCommonParameters::_internal_has_presolve() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool MPSolverCommonParameters::has_presolve() const {
  return _internal_has_presolve();
}
inline void MPSolverCommonParameters::clear_presolve() {
  presolve_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::operations_research::OptionalBoolean MPSolverCommonParameters::_internal_presolve() const {
  return static_cast< ::operations_research::OptionalBoolean >(presolve_);
}
inline ::operations_research::OptionalBoolean MPSolverCommonParameters::presolve() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.presolve)
  return _internal_presolve();
}
inline void MPSolverCommonParameters::_internal_set_presolve(::operations_research::OptionalBoolean value) {
  assert(::operations_research::OptionalBoolean_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  presolve_ = value;
}
inline void MPSolverCommonParameters::set_presolve(::operations_research::OptionalBoolean value) {
  _internal_set_presolve(value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolverCommonParameters.presolve)
}
 
// optional .operations_research.OptionalBoolean scaling = 7 [default = BOOL_UNSPECIFIED];
inline bool MPSolverCommonParameters::_internal_has_scaling() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool MPSolverCommonParameters::has_scaling() const {
  return _internal_has_scaling();
}
inline void MPSolverCommonParameters::clear_scaling() {
  scaling_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::operations_research::OptionalBoolean MPSolverCommonParameters::_internal_scaling() const {
  return static_cast< ::operations_research::OptionalBoolean >(scaling_);
}
inline ::operations_research::OptionalBoolean MPSolverCommonParameters::scaling() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.scaling)
  return _internal_scaling();
}
inline void MPSolverCommonParameters::_internal_set_scaling(::operations_research::OptionalBoolean value) {
  assert(::operations_research::OptionalBoolean_IsValid(value));
  _has_bits_[0] |= 0x00000020u;
  scaling_ = value;
}
inline void MPSolverCommonParameters::set_scaling(::operations_research::OptionalBoolean value) {
  _internal_set_scaling(value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolverCommonParameters.scaling)
}
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// MPModelDeltaProto
 
// optional string baseline_model_file_path = 1;
inline bool MPModelDeltaProto::_internal_has_baseline_model_file_path() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPModelDeltaProto::has_baseline_model_file_path() const {
  return _internal_has_baseline_model_file_path();
}
inline void MPModelDeltaProto::clear_baseline_model_file_path() {
  baseline_model_file_path_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MPModelDeltaProto::baseline_model_file_path() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelDeltaProto.baseline_model_file_path)
  return _internal_baseline_model_file_path();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MPModelDeltaProto::set_baseline_model_file_path(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 baseline_model_file_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.MPModelDeltaProto.baseline_model_file_path)
}
inline std::string* MPModelDeltaProto::mutable_baseline_model_file_path() {
  std::string* _s = _internal_mutable_baseline_model_file_path();
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelDeltaProto.baseline_model_file_path)
  return _s;
}
inline const std::string& MPModelDeltaProto::_internal_baseline_model_file_path() const {
  return baseline_model_file_path_.Get();
}
inline void MPModelDeltaProto::_internal_set_baseline_model_file_path(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  baseline_model_file_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* MPModelDeltaProto::_internal_mutable_baseline_model_file_path() {
  _has_bits_[0] |= 0x00000001u;
  return baseline_model_file_path_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* MPModelDeltaProto::release_baseline_model_file_path() {
  // @@protoc_insertion_point(field_release:operations_research.MPModelDeltaProto.baseline_model_file_path)
  if (!_internal_has_baseline_model_file_path()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = baseline_model_file_path_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (baseline_model_file_path_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    baseline_model_file_path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MPModelDeltaProto::set_allocated_baseline_model_file_path(std::string* baseline_model_file_path) {
  if (baseline_model_file_path != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  baseline_model_file_path_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), baseline_model_file_path,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (baseline_model_file_path_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    baseline_model_file_path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPModelDeltaProto.baseline_model_file_path)
}
 
// map<int32, .operations_research.MPVariableProto> variable_overrides = 2;
inline int MPModelDeltaProto::_internal_variable_overrides_size() const {
  return variable_overrides_.size();
}
inline int MPModelDeltaProto::variable_overrides_size() const {
  return _internal_variable_overrides_size();
}
inline void MPModelDeltaProto::clear_variable_overrides() {
  variable_overrides_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPVariableProto >&
MPModelDeltaProto::_internal_variable_overrides() const {
  return variable_overrides_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPVariableProto >&
MPModelDeltaProto::variable_overrides() const {
  // @@protoc_insertion_point(field_map:operations_research.MPModelDeltaProto.variable_overrides)
  return _internal_variable_overrides();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPVariableProto >*
MPModelDeltaProto::_internal_mutable_variable_overrides() {
  return variable_overrides_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPVariableProto >*
MPModelDeltaProto::mutable_variable_overrides() {
  // @@protoc_insertion_point(field_mutable_map:operations_research.MPModelDeltaProto.variable_overrides)
  return _internal_mutable_variable_overrides();
}
 
// map<int32, .operations_research.MPConstraintProto> constraint_overrides = 3;
inline int MPModelDeltaProto::_internal_constraint_overrides_size() const {
  return constraint_overrides_.size();
}
inline int MPModelDeltaProto::constraint_overrides_size() const {
  return _internal_constraint_overrides_size();
}
inline void MPModelDeltaProto::clear_constraint_overrides() {
  constraint_overrides_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPConstraintProto >&
MPModelDeltaProto::_internal_constraint_overrides() const {
  return constraint_overrides_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPConstraintProto >&
MPModelDeltaProto::constraint_overrides() const {
  // @@protoc_insertion_point(field_map:operations_research.MPModelDeltaProto.constraint_overrides)
  return _internal_constraint_overrides();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPConstraintProto >*
MPModelDeltaProto::_internal_mutable_constraint_overrides() {
  return constraint_overrides_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< int32_t, ::operations_research::MPConstraintProto >*
MPModelDeltaProto::mutable_constraint_overrides() {
  // @@protoc_insertion_point(field_mutable_map:operations_research.MPModelDeltaProto.constraint_overrides)
  return _internal_mutable_constraint_overrides();
}
 
// -------------------------------------------------------------------
 
// MPModelRequest
 
// optional .operations_research.MPModelProto model = 1;
inline bool MPModelRequest::_internal_has_model() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || model_ != nullptr);
  return value;
}
inline bool MPModelRequest::has_model() const {
  return _internal_has_model();
}
inline void MPModelRequest::clear_model() {
  if (model_ != nullptr) model_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::operations_research::MPModelProto& MPModelRequest::_internal_model() const {
  const ::operations_research::MPModelProto* p = model_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::MPModelProto&>(
      ::operations_research::_MPModelProto_default_instance_);
}
inline const ::operations_research::MPModelProto& MPModelRequest::model() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.model)
  return _internal_model();
}
inline void MPModelRequest::unsafe_arena_set_allocated_model(
    ::operations_research::MPModelProto* model) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(model_);
  }
  model_ = model;
  if (model) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPModelRequest.model)
}
inline ::operations_research::MPModelProto* MPModelRequest::release_model() {
  _has_bits_[0] &= ~0x00000002u;
  ::operations_research::MPModelProto* temp = model_;
  model_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::MPModelProto* MPModelRequest::unsafe_arena_release_model() {
  // @@protoc_insertion_point(field_release:operations_research.MPModelRequest.model)
  _has_bits_[0] &= ~0x00000002u;
  ::operations_research::MPModelProto* temp = model_;
  model_ = nullptr;
  return temp;
}
inline ::operations_research::MPModelProto* MPModelRequest::_internal_mutable_model() {
  _has_bits_[0] |= 0x00000002u;
  if (model_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::MPModelProto>(GetArenaForAllocation());
    model_ = p;
  }
  return model_;
}
inline ::operations_research::MPModelProto* MPModelRequest::mutable_model() {
  ::operations_research::MPModelProto* _msg = _internal_mutable_model();
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelRequest.model)
  return _msg;
}
inline void MPModelRequest::set_allocated_model(::operations_research::MPModelProto* model) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete model_;
  }
  if (model) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPModelProto>::GetOwningArena(model);
    if (message_arena != submessage_arena) {
      model = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, model, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  model_ = model;
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPModelRequest.model)
}
 
// optional .operations_research.MPModelRequest.SolverType solver_type = 2;
inline bool MPModelRequest::_internal_has_solver_type() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool MPModelRequest::has_solver_type() const {
  return _internal_has_solver_type();
}
inline void MPModelRequest::clear_solver_type() {
  solver_type_ = 2;
  _has_bits_[0] &= ~0x00000080u;
}
inline ::operations_research::MPModelRequest_SolverType MPModelRequest::_internal_solver_type() const {
  return static_cast< ::operations_research::MPModelRequest_SolverType >(solver_type_);
}
inline ::operations_research::MPModelRequest_SolverType MPModelRequest::solver_type() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.solver_type)
  return _internal_solver_type();
}
inline void MPModelRequest::_internal_set_solver_type(::operations_research::MPModelRequest_SolverType value) {
  assert(::operations_research::MPModelRequest_SolverType_IsValid(value));
  _has_bits_[0] |= 0x00000080u;
  solver_type_ = value;
}
inline void MPModelRequest::set_solver_type(::operations_research::MPModelRequest_SolverType value) {
  _internal_set_solver_type(value);
  // @@protoc_insertion_point(field_set:operations_research.MPModelRequest.solver_type)
}
 
// optional double solver_time_limit_seconds = 3;
inline bool MPModelRequest::_internal_has_solver_time_limit_seconds() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MPModelRequest::has_solver_time_limit_seconds() const {
  return _internal_has_solver_time_limit_seconds();
}
inline void MPModelRequest::clear_solver_time_limit_seconds() {
  solver_time_limit_seconds_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline double MPModelRequest::_internal_solver_time_limit_seconds() const {
  return solver_time_limit_seconds_;
}
inline double MPModelRequest::solver_time_limit_seconds() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.solver_time_limit_seconds)
  return _internal_solver_time_limit_seconds();
}
inline void MPModelRequest::_internal_set_solver_time_limit_seconds(double value) {
  _has_bits_[0] |= 0x00000008u;
  solver_time_limit_seconds_ = value;
}
inline void MPModelRequest::set_solver_time_limit_seconds(double value) {
  _internal_set_solver_time_limit_seconds(value);
  // @@protoc_insertion_point(field_set:operations_research.MPModelRequest.solver_time_limit_seconds)
}
 
// optional bool enable_internal_solver_output = 4 [default = false];
inline bool MPModelRequest::_internal_has_enable_internal_solver_output() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool MPModelRequest::has_enable_internal_solver_output() const {
  return _internal_has_enable_internal_solver_output();
}
inline void MPModelRequest::clear_enable_internal_solver_output() {
  enable_internal_solver_output_ = false;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool MPModelRequest::_internal_enable_internal_solver_output() const {
  return enable_internal_solver_output_;
}
inline bool MPModelRequest::enable_internal_solver_output() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.enable_internal_solver_output)
  return _internal_enable_internal_solver_output();
}
inline void MPModelRequest::_internal_set_enable_internal_solver_output(bool value) {
  _has_bits_[0] |= 0x00000010u;
  enable_internal_solver_output_ = value;
}
inline void MPModelRequest::set_enable_internal_solver_output(bool value) {
  _internal_set_enable_internal_solver_output(value);
  // @@protoc_insertion_point(field_set:operations_research.MPModelRequest.enable_internal_solver_output)
}
 
// optional string solver_specific_parameters = 5;
inline bool MPModelRequest::_internal_has_solver_specific_parameters() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPModelRequest::has_solver_specific_parameters() const {
  return _internal_has_solver_specific_parameters();
}
inline void MPModelRequest::clear_solver_specific_parameters() {
  solver_specific_parameters_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MPModelRequest::solver_specific_parameters() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.solver_specific_parameters)
  return _internal_solver_specific_parameters();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MPModelRequest::set_solver_specific_parameters(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 solver_specific_parameters_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.MPModelRequest.solver_specific_parameters)
}
inline std::string* MPModelRequest::mutable_solver_specific_parameters() {
  std::string* _s = _internal_mutable_solver_specific_parameters();
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelRequest.solver_specific_parameters)
  return _s;
}
inline const std::string& MPModelRequest::_internal_solver_specific_parameters() const {
  return solver_specific_parameters_.Get();
}
inline void MPModelRequest::_internal_set_solver_specific_parameters(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  solver_specific_parameters_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* MPModelRequest::_internal_mutable_solver_specific_parameters() {
  _has_bits_[0] |= 0x00000001u;
  return solver_specific_parameters_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* MPModelRequest::release_solver_specific_parameters() {
  // @@protoc_insertion_point(field_release:operations_research.MPModelRequest.solver_specific_parameters)
  if (!_internal_has_solver_specific_parameters()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = solver_specific_parameters_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (solver_specific_parameters_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    solver_specific_parameters_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MPModelRequest::set_allocated_solver_specific_parameters(std::string* solver_specific_parameters) {
  if (solver_specific_parameters != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  solver_specific_parameters_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), solver_specific_parameters,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (solver_specific_parameters_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    solver_specific_parameters_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPModelRequest.solver_specific_parameters)
}
 
// optional bool ignore_solver_specific_parameters_failure = 9 [default = false];
inline bool MPModelRequest::_internal_has_ignore_solver_specific_parameters_failure() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool MPModelRequest::has_ignore_solver_specific_parameters_failure() const {
  return _internal_has_ignore_solver_specific_parameters_failure();
}
inline void MPModelRequest::clear_ignore_solver_specific_parameters_failure() {
  ignore_solver_specific_parameters_failure_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool MPModelRequest::_internal_ignore_solver_specific_parameters_failure() const {
  return ignore_solver_specific_parameters_failure_;
}
inline bool MPModelRequest::ignore_solver_specific_parameters_failure() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.ignore_solver_specific_parameters_failure)
  return _internal_ignore_solver_specific_parameters_failure();
}
inline void MPModelRequest::_internal_set_ignore_solver_specific_parameters_failure(bool value) {
  _has_bits_[0] |= 0x00000020u;
  ignore_solver_specific_parameters_failure_ = value;
}
inline void MPModelRequest::set_ignore_solver_specific_parameters_failure(bool value) {
  _internal_set_ignore_solver_specific_parameters_failure(value);
  // @@protoc_insertion_point(field_set:operations_research.MPModelRequest.ignore_solver_specific_parameters_failure)
}
 
// optional .operations_research.MPModelDeltaProto model_delta = 8;
inline bool MPModelRequest::_internal_has_model_delta() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || model_delta_ != nullptr);
  return value;
}
inline bool MPModelRequest::has_model_delta() const {
  return _internal_has_model_delta();
}
inline void MPModelRequest::clear_model_delta() {
  if (model_delta_ != nullptr) model_delta_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::operations_research::MPModelDeltaProto& MPModelRequest::_internal_model_delta() const {
  const ::operations_research::MPModelDeltaProto* p = model_delta_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::MPModelDeltaProto&>(
      ::operations_research::_MPModelDeltaProto_default_instance_);
}
inline const ::operations_research::MPModelDeltaProto& MPModelRequest::model_delta() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.model_delta)
  return _internal_model_delta();
}
inline void MPModelRequest::unsafe_arena_set_allocated_model_delta(
    ::operations_research::MPModelDeltaProto* model_delta) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(model_delta_);
  }
  model_delta_ = model_delta;
  if (model_delta) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPModelRequest.model_delta)
}
inline ::operations_research::MPModelDeltaProto* MPModelRequest::release_model_delta() {
  _has_bits_[0] &= ~0x00000004u;
  ::operations_research::MPModelDeltaProto* temp = model_delta_;
  model_delta_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::MPModelDeltaProto* MPModelRequest::unsafe_arena_release_model_delta() {
  // @@protoc_insertion_point(field_release:operations_research.MPModelRequest.model_delta)
  _has_bits_[0] &= ~0x00000004u;
  ::operations_research::MPModelDeltaProto* temp = model_delta_;
  model_delta_ = nullptr;
  return temp;
}
inline ::operations_research::MPModelDeltaProto* MPModelRequest::_internal_mutable_model_delta() {
  _has_bits_[0] |= 0x00000004u;
  if (model_delta_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::MPModelDeltaProto>(GetArenaForAllocation());
    model_delta_ = p;
  }
  return model_delta_;
}
inline ::operations_research::MPModelDeltaProto* MPModelRequest::mutable_model_delta() {
  ::operations_research::MPModelDeltaProto* _msg = _internal_mutable_model_delta();
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelRequest.model_delta)
  return _msg;
}
inline void MPModelRequest::set_allocated_model_delta(::operations_research::MPModelDeltaProto* model_delta) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete model_delta_;
  }
  if (model_delta) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPModelDeltaProto>::GetOwningArena(model_delta);
    if (message_arena != submessage_arena) {
      model_delta = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, model_delta, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  model_delta_ = model_delta;
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPModelRequest.model_delta)
}
 
// optional int32 populate_additional_solutions_up_to = 11 [default = 0];
inline bool MPModelRequest::_internal_has_populate_additional_solutions_up_to() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool MPModelRequest::has_populate_additional_solutions_up_to() const {
  return _internal_has_populate_additional_solutions_up_to();
}
inline void MPModelRequest::clear_populate_additional_solutions_up_to() {
  populate_additional_solutions_up_to_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline int32_t MPModelRequest::_internal_populate_additional_solutions_up_to() const {
  return populate_additional_solutions_up_to_;
}
inline int32_t MPModelRequest::populate_additional_solutions_up_to() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.populate_additional_solutions_up_to)
  return _internal_populate_additional_solutions_up_to();
}
inline void MPModelRequest::_internal_set_populate_additional_solutions_up_to(int32_t value) {
  _has_bits_[0] |= 0x00000040u;
  populate_additional_solutions_up_to_ = value;
}
inline void MPModelRequest::set_populate_additional_solutions_up_to(int32_t value) {
  _internal_set_populate_additional_solutions_up_to(value);
  // @@protoc_insertion_point(field_set:operations_research.MPModelRequest.populate_additional_solutions_up_to)
}
 
// -------------------------------------------------------------------
 
// MPSolution
 
// optional double objective_value = 1;
inline bool MPSolution::_internal_has_objective_value() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPSolution::has_objective_value() const {
  return _internal_has_objective_value();
}
inline void MPSolution::clear_objective_value() {
  objective_value_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline double MPSolution::_internal_objective_value() const {
  return objective_value_;
}
inline double MPSolution::objective_value() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolution.objective_value)
  return _internal_objective_value();
}
inline void MPSolution::_internal_set_objective_value(double value) {
  _has_bits_[0] |= 0x00000001u;
  objective_value_ = value;
}
inline void MPSolution::set_objective_value(double value) {
  _internal_set_objective_value(value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolution.objective_value)
}
 
// repeated double variable_value = 2 [packed = true];
inline int MPSolution::_internal_variable_value_size() const {
  return variable_value_.size();
}
inline int MPSolution::variable_value_size() const {
  return _internal_variable_value_size();
}
inline void MPSolution::clear_variable_value() {
  variable_value_.Clear();
}
inline double MPSolution::_internal_variable_value(int index) const {
  return variable_value_.Get(index);
}
inline double MPSolution::variable_value(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolution.variable_value)
  return _internal_variable_value(index);
}
inline void MPSolution::set_variable_value(int index, double value) {
  variable_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolution.variable_value)
}
inline void MPSolution::_internal_add_variable_value(double value) {
  variable_value_.Add(value);
}
inline void MPSolution::add_variable_value(double value) {
  _internal_add_variable_value(value);
  // @@protoc_insertion_point(field_add:operations_research.MPSolution.variable_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSolution::_internal_variable_value() const {
  return variable_value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSolution::variable_value() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSolution.variable_value)
  return _internal_variable_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPSolution::_internal_mutable_variable_value() {
  return &variable_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPSolution::mutable_variable_value() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPSolution.variable_value)
  return _internal_mutable_variable_value();
}
 
// -------------------------------------------------------------------
 
// MPSolveInfo
 
// optional double solve_wall_time_seconds = 1;
inline bool MPSolveInfo::_internal_has_solve_wall_time_seconds() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPSolveInfo::has_solve_wall_time_seconds() const {
  return _internal_has_solve_wall_time_seconds();
}
inline void MPSolveInfo::clear_solve_wall_time_seconds() {
  solve_wall_time_seconds_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline double MPSolveInfo::_internal_solve_wall_time_seconds() const {
  return solve_wall_time_seconds_;
}
inline double MPSolveInfo::solve_wall_time_seconds() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolveInfo.solve_wall_time_seconds)
  return _internal_solve_wall_time_seconds();
}
inline void MPSolveInfo::_internal_set_solve_wall_time_seconds(double value) {
  _has_bits_[0] |= 0x00000001u;
  solve_wall_time_seconds_ = value;
}
inline void MPSolveInfo::set_solve_wall_time_seconds(double value) {
  _internal_set_solve_wall_time_seconds(value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolveInfo.solve_wall_time_seconds)
}
 
// optional double solve_user_time_seconds = 2;
inline bool MPSolveInfo::_internal_has_solve_user_time_seconds() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MPSolveInfo::has_solve_user_time_seconds() const {
  return _internal_has_solve_user_time_seconds();
}
inline void MPSolveInfo::clear_solve_user_time_seconds() {
  solve_user_time_seconds_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline double MPSolveInfo::_internal_solve_user_time_seconds() const {
  return solve_user_time_seconds_;
}
inline double MPSolveInfo::solve_user_time_seconds() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolveInfo.solve_user_time_seconds)
  return _internal_solve_user_time_seconds();
}
inline void MPSolveInfo::_internal_set_solve_user_time_seconds(double value) {
  _has_bits_[0] |= 0x00000002u;
  solve_user_time_seconds_ = value;
}
inline void MPSolveInfo::set_solve_user_time_seconds(double value) {
  _internal_set_solve_user_time_seconds(value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolveInfo.solve_user_time_seconds)
}
 
// -------------------------------------------------------------------
 
// MPSolutionResponse
 
// optional .operations_research.MPSolverResponseStatus status = 1 [default = MPSOLVER_UNKNOWN_STATUS];
inline bool MPSolutionResponse::_internal_has_status() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool MPSolutionResponse::has_status() const {
  return _internal_has_status();
}
inline void MPSolutionResponse::clear_status() {
  status_ = 99;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::operations_research::MPSolverResponseStatus MPSolutionResponse::_internal_status() const {
  return static_cast< ::operations_research::MPSolverResponseStatus >(status_);
}
inline ::operations_research::MPSolverResponseStatus MPSolutionResponse::status() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.status)
  return _internal_status();
}
inline void MPSolutionResponse::_internal_set_status(::operations_research::MPSolverResponseStatus value) {
  assert(::operations_research::MPSolverResponseStatus_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  status_ = value;
}
inline void MPSolutionResponse::set_status(::operations_research::MPSolverResponseStatus value) {
  _internal_set_status(value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolutionResponse.status)
}
 
// optional string status_str = 7;
inline bool MPSolutionResponse::_internal_has_status_str() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MPSolutionResponse::has_status_str() const {
  return _internal_has_status_str();
}
inline void MPSolutionResponse::clear_status_str() {
  status_str_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MPSolutionResponse::status_str() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.status_str)
  return _internal_status_str();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MPSolutionResponse::set_status_str(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 status_str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.MPSolutionResponse.status_str)
}
inline std::string* MPSolutionResponse::mutable_status_str() {
  std::string* _s = _internal_mutable_status_str();
  // @@protoc_insertion_point(field_mutable:operations_research.MPSolutionResponse.status_str)
  return _s;
}
inline const std::string& MPSolutionResponse::_internal_status_str() const {
  return status_str_.Get();
}
inline void MPSolutionResponse::_internal_set_status_str(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  status_str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* MPSolutionResponse::_internal_mutable_status_str() {
  _has_bits_[0] |= 0x00000001u;
  return status_str_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* MPSolutionResponse::release_status_str() {
  // @@protoc_insertion_point(field_release:operations_research.MPSolutionResponse.status_str)
  if (!_internal_has_status_str()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = status_str_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (status_str_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    status_str_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MPSolutionResponse::set_allocated_status_str(std::string* status_str) {
  if (status_str != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  status_str_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), status_str,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (status_str_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    status_str_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPSolutionResponse.status_str)
}
 
// optional double objective_value = 2;
inline bool MPSolutionResponse::_internal_has_objective_value() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MPSolutionResponse::has_objective_value() const {
  return _internal_has_objective_value();
}
inline void MPSolutionResponse::clear_objective_value() {
  objective_value_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline double MPSolutionResponse::_internal_objective_value() const {
  return objective_value_;
}
inline double MPSolutionResponse::objective_value() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.objective_value)
  return _internal_objective_value();
}
inline void MPSolutionResponse::_internal_set_objective_value(double value) {
  _has_bits_[0] |= 0x00000004u;
  objective_value_ = value;
}
inline void MPSolutionResponse::set_objective_value(double value) {
  _internal_set_objective_value(value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolutionResponse.objective_value)
}
 
// optional double best_objective_bound = 5;
inline bool MPSolutionResponse::_internal_has_best_objective_bound() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MPSolutionResponse::has_best_objective_bound() const {
  return _internal_has_best_objective_bound();
}
inline void MPSolutionResponse::clear_best_objective_bound() {
  best_objective_bound_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline double MPSolutionResponse::_internal_best_objective_bound() const {
  return best_objective_bound_;
}
inline double MPSolutionResponse::best_objective_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.best_objective_bound)
  return _internal_best_objective_bound();
}
inline void MPSolutionResponse::_internal_set_best_objective_bound(double value) {
  _has_bits_[0] |= 0x00000008u;
  best_objective_bound_ = value;
}
inline void MPSolutionResponse::set_best_objective_bound(double value) {
  _internal_set_best_objective_bound(value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolutionResponse.best_objective_bound)
}
 
// repeated double variable_value = 3 [packed = true];
inline int MPSolutionResponse::_internal_variable_value_size() const {
  return variable_value_.size();
}
inline int MPSolutionResponse::variable_value_size() const {
  return _internal_variable_value_size();
}
inline void MPSolutionResponse::clear_variable_value() {
  variable_value_.Clear();
}
inline double MPSolutionResponse::_internal_variable_value(int index) const {
  return variable_value_.Get(index);
}
inline double MPSolutionResponse::variable_value(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.variable_value)
  return _internal_variable_value(index);
}
inline void MPSolutionResponse::set_variable_value(int index, double value) {
  variable_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolutionResponse.variable_value)
}
inline void MPSolutionResponse::_internal_add_variable_value(double value) {
  variable_value_.Add(value);
}
inline void MPSolutionResponse::add_variable_value(double value) {
  _internal_add_variable_value(value);
  // @@protoc_insertion_point(field_add:operations_research.MPSolutionResponse.variable_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSolutionResponse::_internal_variable_value() const {
  return variable_value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSolutionResponse::variable_value() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSolutionResponse.variable_value)
  return _internal_variable_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPSolutionResponse::_internal_mutable_variable_value() {
  return &variable_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPSolutionResponse::mutable_variable_value() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPSolutionResponse.variable_value)
  return _internal_mutable_variable_value();
}
 
// optional .operations_research.MPSolveInfo solve_info = 10;
inline bool MPSolutionResponse::_internal_has_solve_info() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || solve_info_ != nullptr);
  return value;
}
inline bool MPSolutionResponse::has_solve_info() const {
  return _internal_has_solve_info();
}
inline void MPSolutionResponse::clear_solve_info() {
  if (solve_info_ != nullptr) solve_info_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::operations_research::MPSolveInfo& MPSolutionResponse::_internal_solve_info() const {
  const ::operations_research::MPSolveInfo* p = solve_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::MPSolveInfo&>(
      ::operations_research::_MPSolveInfo_default_instance_);
}
inline const ::operations_research::MPSolveInfo& MPSolutionResponse::solve_info() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.solve_info)
  return _internal_solve_info();
}
inline void MPSolutionResponse::unsafe_arena_set_allocated_solve_info(
    ::operations_research::MPSolveInfo* solve_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(solve_info_);
  }
  solve_info_ = solve_info;
  if (solve_info) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.MPSolutionResponse.solve_info)
}
inline ::operations_research::MPSolveInfo* MPSolutionResponse::release_solve_info() {
  _has_bits_[0] &= ~0x00000002u;
  ::operations_research::MPSolveInfo* temp = solve_info_;
  solve_info_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::MPSolveInfo* MPSolutionResponse::unsafe_arena_release_solve_info() {
  // @@protoc_insertion_point(field_release:operations_research.MPSolutionResponse.solve_info)
  _has_bits_[0] &= ~0x00000002u;
  ::operations_research::MPSolveInfo* temp = solve_info_;
  solve_info_ = nullptr;
  return temp;
}
inline ::operations_research::MPSolveInfo* MPSolutionResponse::_internal_mutable_solve_info() {
  _has_bits_[0] |= 0x00000002u;
  if (solve_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::MPSolveInfo>(GetArenaForAllocation());
    solve_info_ = p;
  }
  return solve_info_;
}
inline ::operations_research::MPSolveInfo* MPSolutionResponse::mutable_solve_info() {
  ::operations_research::MPSolveInfo* _msg = _internal_mutable_solve_info();
  // @@protoc_insertion_point(field_mutable:operations_research.MPSolutionResponse.solve_info)
  return _msg;
}
inline void MPSolutionResponse::set_allocated_solve_info(::operations_research::MPSolveInfo* solve_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete solve_info_;
  }
  if (solve_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPSolveInfo>::GetOwningArena(solve_info);
    if (message_arena != submessage_arena) {
      solve_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, solve_info, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  solve_info_ = solve_info;
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPSolutionResponse.solve_info)
}
 
// repeated double dual_value = 4 [packed = true];
inline int MPSolutionResponse::_internal_dual_value_size() const {
  return dual_value_.size();
}
inline int MPSolutionResponse::dual_value_size() const {
  return _internal_dual_value_size();
}
inline void MPSolutionResponse::clear_dual_value() {
  dual_value_.Clear();
}
inline double MPSolutionResponse::_internal_dual_value(int index) const {
  return dual_value_.Get(index);
}
inline double MPSolutionResponse::dual_value(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.dual_value)
  return _internal_dual_value(index);
}
inline void MPSolutionResponse::set_dual_value(int index, double value) {
  dual_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolutionResponse.dual_value)
}
inline void MPSolutionResponse::_internal_add_dual_value(double value) {
  dual_value_.Add(value);
}
inline void MPSolutionResponse::add_dual_value(double value) {
  _internal_add_dual_value(value);
  // @@protoc_insertion_point(field_add:operations_research.MPSolutionResponse.dual_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSolutionResponse::_internal_dual_value() const {
  return dual_value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSolutionResponse::dual_value() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSolutionResponse.dual_value)
  return _internal_dual_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPSolutionResponse::_internal_mutable_dual_value() {
  return &dual_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPSolutionResponse::mutable_dual_value() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPSolutionResponse.dual_value)
  return _internal_mutable_dual_value();
}
 
// repeated double reduced_cost = 6 [packed = true];
inline int MPSolutionResponse::_internal_reduced_cost_size() const {
  return reduced_cost_.size();
}
inline int MPSolutionResponse::reduced_cost_size() const {
  return _internal_reduced_cost_size();
}
inline void MPSolutionResponse::clear_reduced_cost() {
  reduced_cost_.Clear();
}
inline double MPSolutionResponse::_internal_reduced_cost(int index) const {
  return reduced_cost_.Get(index);
}
inline double MPSolutionResponse::reduced_cost(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.reduced_cost)
  return _internal_reduced_cost(index);
}
inline void MPSolutionResponse::set_reduced_cost(int index, double value) {
  reduced_cost_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPSolutionResponse.reduced_cost)
}
inline void MPSolutionResponse::_internal_add_reduced_cost(double value) {
  reduced_cost_.Add(value);
}
inline void MPSolutionResponse::add_reduced_cost(double value) {
  _internal_add_reduced_cost(value);
  // @@protoc_insertion_point(field_add:operations_research.MPSolutionResponse.reduced_cost)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSolutionResponse::_internal_reduced_cost() const {
  return reduced_cost_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSolutionResponse::reduced_cost() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSolutionResponse.reduced_cost)
  return _internal_reduced_cost();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPSolutionResponse::_internal_mutable_reduced_cost() {
  return &reduced_cost_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPSolutionResponse::mutable_reduced_cost() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPSolutionResponse.reduced_cost)
  return _internal_mutable_reduced_cost();
}
 
// repeated .operations_research.MPSolution additional_solutions = 8;
inline int MPSolutionResponse::_internal_additional_solutions_size() const {
  return additional_solutions_.size();
}
inline int MPSolutionResponse::additional_solutions_size() const {
  return _internal_additional_solutions_size();
}
inline void MPSolutionResponse::clear_additional_solutions() {
  additional_solutions_.Clear();
}
inline ::operations_research::MPSolution* MPSolutionResponse::mutable_additional_solutions(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.MPSolutionResponse.additional_solutions)
  return additional_solutions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPSolution >*
MPSolutionResponse::mutable_additional_solutions() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPSolutionResponse.additional_solutions)
  return &additional_solutions_;
}
inline const ::operations_research::MPSolution& MPSolutionResponse::_internal_additional_solutions(int index) const {
  return additional_solutions_.Get(index);
}
inline const ::operations_research::MPSolution& MPSolutionResponse::additional_solutions(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.additional_solutions)
  return _internal_additional_solutions(index);
}
inline ::operations_research::MPSolution* MPSolutionResponse::_internal_add_additional_solutions() {
  return additional_solutions_.Add();
}
inline ::operations_research::MPSolution* MPSolutionResponse::add_additional_solutions() {
  ::operations_research::MPSolution* _add = _internal_add_additional_solutions();
  // @@protoc_insertion_point(field_add:operations_research.MPSolutionResponse.additional_solutions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPSolution >&
MPSolutionResponse::additional_solutions() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSolutionResponse.additional_solutions)
  return additional_solutions_;
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace operations_research
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::operations_research::MPSosConstraint_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::MPSosConstraint_Type>() {
  return ::operations_research::MPSosConstraint_Type_descriptor();
}
template <> struct is_proto_enum< ::operations_research::MPSolverCommonParameters_LPAlgorithmValues> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::MPSolverCommonParameters_LPAlgorithmValues>() {
  return ::operations_research::MPSolverCommonParameters_LPAlgorithmValues_descriptor();
}
template <> struct is_proto_enum< ::operations_research::MPModelRequest_SolverType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::MPModelRequest_SolverType>() {
  return ::operations_research::MPModelRequest_SolverType_descriptor();
}
template <> struct is_proto_enum< ::operations_research::MPSolverResponseStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::MPSolverResponseStatus>() {
  return ::operations_research::MPSolverResponseStatus_descriptor();
}
 
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
 
#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto