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 < 3008000
#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 3008000 < 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/inlined_string_field.h>
#include <google/protobuf/metadata.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/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::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[11]
    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 ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
namespace operations_research {
class MPConstraintProto;
class MPConstraintProtoDefaultTypeInternal;
extern MPConstraintProtoDefaultTypeInternal _MPConstraintProto_default_instance_;
class MPGeneralConstraintProto;
class MPGeneralConstraintProtoDefaultTypeInternal;
extern MPGeneralConstraintProtoDefaultTypeInternal _MPGeneralConstraintProto_default_instance_;
class MPIndicatorConstraint;
class MPIndicatorConstraintDefaultTypeInternal;
extern MPIndicatorConstraintDefaultTypeInternal _MPIndicatorConstraint_default_instance_;
class MPModelProto;
class MPModelProtoDefaultTypeInternal;
extern MPModelProtoDefaultTypeInternal _MPModelProto_default_instance_;
class MPModelRequest;
class MPModelRequestDefaultTypeInternal;
extern MPModelRequestDefaultTypeInternal _MPModelRequest_default_instance_;
class MPSolutionResponse;
class MPSolutionResponseDefaultTypeInternal;
extern MPSolutionResponseDefaultTypeInternal _MPSolutionResponse_default_instance_;
class MPSolverCommonParameters;
class MPSolverCommonParametersDefaultTypeInternal;
extern MPSolverCommonParametersDefaultTypeInternal _MPSolverCommonParameters_default_instance_;
class MPSosConstraint;
class MPSosConstraintDefaultTypeInternal;
extern MPSosConstraintDefaultTypeInternal _MPSosConstraint_default_instance_;
class MPVariableProto;
class MPVariableProtoDefaultTypeInternal;
extern MPVariableProtoDefaultTypeInternal _MPVariableProto_default_instance_;
class OptionalDouble;
class OptionalDoubleDefaultTypeInternal;
extern OptionalDoubleDefaultTypeInternal _OptionalDouble_default_instance_;
class PartialVariableAssignment;
class PartialVariableAssignmentDefaultTypeInternal;
extern PartialVariableAssignmentDefaultTypeInternal _PartialVariableAssignment_default_instance_;
}  // namespace operations_research
PROTOBUF_NAMESPACE_OPEN
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::MPModelProto* Arena::CreateMaybeMessage<::operations_research::MPModelProto>(Arena*);
template<> ::operations_research::MPModelRequest* Arena::CreateMaybeMessage<::operations_research::MPModelRequest>(Arena*);
template<> ::operations_research::MPSolutionResponse* Arena::CreateMaybeMessage<::operations_research::MPSolutionResponse>(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(
    const std::string& 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(
    const std::string& 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_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_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_SAT_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(
    const std::string& 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_UNKNOWN_STATUS = 99,
  MPSOLVER_MODEL_INVALID = 5,
  MPSOLVER_MODEL_INVALID_SOLUTION_HINT = 84,
  MPSOLVER_MODEL_INVALID_SOLVER_PARAMETERS = 85,
  MPSOLVER_SOLVER_TYPE_UNAVAILABLE = 7
};
bool MPSolverResponseStatus_IsValid(int value);
constexpr MPSolverResponseStatus MPSolverResponseStatus_MIN = MPSOLVER_OPTIMAL;
constexpr MPSolverResponseStatus MPSolverResponseStatus_MAX = MPSOLVER_UNKNOWN_STATUS;
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(
    const std::string& name, MPSolverResponseStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MPSolverResponseStatus>(
    MPSolverResponseStatus_descriptor(), name, value);
}
// ===================================================================

class MPVariableProto :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPVariableProto) */ {
 public:
  MPVariableProto();
  virtual ~MPVariableProto();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MPVariableProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MPVariableProto* internal_default_instance() {
    return reinterpret_cast<const MPVariableProto*>(
               &_MPVariableProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void Swap(MPVariableProto* other);
  friend void swap(MPVariableProto& a, MPVariableProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline MPVariableProto* New() const final {
    return CreateMaybeMessage<MPVariableProto>(nullptr);
  }

  MPVariableProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MPVariableProto>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MPVariableProto& from);
  void MergeFrom(const MPVariableProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPVariableProto* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPVariableProto";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
    return ::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string name = 5 [default = ""];
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 5;
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // optional double objective_coefficient = 3 [default = 0];
  bool has_objective_coefficient() const;
  void clear_objective_coefficient();
  static const int kObjectiveCoefficientFieldNumber = 3;
  double objective_coefficient() const;
  void set_objective_coefficient(double value);

  // optional bool is_integer = 4 [default = false];
  bool has_is_integer() const;
  void clear_is_integer();
  static const int kIsIntegerFieldNumber = 4;
  bool is_integer() const;
  void set_is_integer(bool value);

  // optional int32 branching_priority = 6 [default = 0];
  bool has_branching_priority() const;
  void clear_branching_priority();
  static const int kBranchingPriorityFieldNumber = 6;
  ::PROTOBUF_NAMESPACE_ID::int32 branching_priority() const;
  void set_branching_priority(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional double lower_bound = 1 [default = -inf];
  bool has_lower_bound() const;
  void clear_lower_bound();
  static const int kLowerBoundFieldNumber = 1;
  double lower_bound() const;
  void set_lower_bound(double value);

  // optional double upper_bound = 2 [default = inf];
  bool has_upper_bound() const;
  void clear_upper_bound();
  static const int kUpperBoundFieldNumber = 2;
  double upper_bound() const;
  void set_upper_bound(double value);

  // @@protoc_insertion_point(class_scope:operations_research.MPVariableProto)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::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_;
  ::PROTOBUF_NAMESPACE_ID::int32 branching_priority_;
  double lower_bound_;
  double upper_bound_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------

class MPConstraintProto :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPConstraintProto) */ {
 public:
  MPConstraintProto();
  virtual ~MPConstraintProto();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MPConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MPConstraintProto* internal_default_instance() {
    return reinterpret_cast<const MPConstraintProto*>(
               &_MPConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  void Swap(MPConstraintProto* other);
  friend void swap(MPConstraintProto& a, MPConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline MPConstraintProto* New() const final {
    return CreateMaybeMessage<MPConstraintProto>(nullptr);
  }

  MPConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MPConstraintProto>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MPConstraintProto& from);
  void MergeFrom(const MPConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPConstraintProto* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPConstraintProto";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
    return ::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 var_index = 6 [packed = true];
  int var_index_size() const;
  void clear_var_index();
  static const int kVarIndexFieldNumber = 6;
  ::PROTOBUF_NAMESPACE_ID::int32 var_index(int index) const;
  void set_var_index(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
  void add_var_index(::PROTOBUF_NAMESPACE_ID::int32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      var_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      mutable_var_index();

  // repeated double coefficient = 7 [packed = true];
  int coefficient_size() const;
  void clear_coefficient();
  static const int kCoefficientFieldNumber = 7;
  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;
  void clear_name();
  static const int kNameFieldNumber = 4;
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // optional bool is_lazy = 5 [default = false];
  bool has_is_lazy() const;
  void clear_is_lazy();
  static const int kIsLazyFieldNumber = 5;
  bool is_lazy() const;
  void set_is_lazy(bool value);

  // optional double lower_bound = 2 [default = -inf];
  bool has_lower_bound() const;
  void clear_lower_bound();
  static const int kLowerBoundFieldNumber = 2;
  double lower_bound() const;
  void set_lower_bound(double value);

  // optional double upper_bound = 3 [default = inf];
  bool has_upper_bound() const;
  void clear_upper_bound();
  static const int kUpperBoundFieldNumber = 3;
  double upper_bound() const;
  void set_upper_bound(double value);

  // @@protoc_insertion_point(class_scope:operations_research.MPConstraintProto)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > var_index_;
  mutable std::atomic<int> _var_index_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > coefficient_;
  mutable std::atomic<int> _coefficient_cached_byte_size_;
  ::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 :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPGeneralConstraintProto) */ {
 public:
  MPGeneralConstraintProto();
  virtual ~MPGeneralConstraintProto();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MPGeneralConstraintProto& default_instance();

  enum GeneralConstraintCase {
    kIndicatorConstraint = 2,
    kSosConstraint = 3,
    GENERAL_CONSTRAINT_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MPGeneralConstraintProto* internal_default_instance() {
    return reinterpret_cast<const MPGeneralConstraintProto*>(
               &_MPGeneralConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  void Swap(MPGeneralConstraintProto* other);
  friend void swap(MPGeneralConstraintProto& a, MPGeneralConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline MPGeneralConstraintProto* New() const final {
    return CreateMaybeMessage<MPGeneralConstraintProto>(nullptr);
  }

  MPGeneralConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MPGeneralConstraintProto>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MPGeneralConstraintProto& from);
  void MergeFrom(const MPGeneralConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPGeneralConstraintProto* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPGeneralConstraintProto";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
    return ::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string name = 1 [default = ""];
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // optional .operations_research.MPIndicatorConstraint indicator_constraint = 2;
  bool has_indicator_constraint() const;
  void clear_indicator_constraint();
  static const int kIndicatorConstraintFieldNumber = 2;
  const ::operations_research::MPIndicatorConstraint& indicator_constraint() const;
  ::operations_research::MPIndicatorConstraint* release_indicator_constraint();
  ::operations_research::MPIndicatorConstraint* mutable_indicator_constraint();
  void set_allocated_indicator_constraint(::operations_research::MPIndicatorConstraint* indicator_constraint);

  // optional .operations_research.MPSosConstraint sos_constraint = 3;
  bool has_sos_constraint() const;
  void clear_sos_constraint();
  static const int kSosConstraintFieldNumber = 3;
  const ::operations_research::MPSosConstraint& sos_constraint() const;
  ::operations_research::MPSosConstraint* release_sos_constraint();
  ::operations_research::MPSosConstraint* mutable_sos_constraint();
  void set_allocated_sos_constraint(::operations_research::MPSosConstraint* sos_constraint);

  void clear_general_constraint();
  GeneralConstraintCase general_constraint_case() const;
  // @@protoc_insertion_point(class_scope:operations_research.MPGeneralConstraintProto)
 private:
  class HasBitSetters;
  void set_has_indicator_constraint();
  void set_has_sos_constraint();

  inline bool has_general_constraint() const;
  inline void clear_has_general_constraint();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  union GeneralConstraintUnion {
    GeneralConstraintUnion() {}
    ::operations_research::MPIndicatorConstraint* indicator_constraint_;
    ::operations_research::MPSosConstraint* sos_constraint_;
  } general_constraint_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------

class MPIndicatorConstraint :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPIndicatorConstraint) */ {
 public:
  MPIndicatorConstraint();
  virtual ~MPIndicatorConstraint();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MPIndicatorConstraint& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MPIndicatorConstraint* internal_default_instance() {
    return reinterpret_cast<const MPIndicatorConstraint*>(
               &_MPIndicatorConstraint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  void Swap(MPIndicatorConstraint* other);
  friend void swap(MPIndicatorConstraint& a, MPIndicatorConstraint& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline MPIndicatorConstraint* New() const final {
    return CreateMaybeMessage<MPIndicatorConstraint>(nullptr);
  }

  MPIndicatorConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MPIndicatorConstraint>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MPIndicatorConstraint& from);
  void MergeFrom(const MPIndicatorConstraint& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPIndicatorConstraint* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPIndicatorConstraint";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
    return ::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .operations_research.MPConstraintProto constraint = 3;
  bool has_constraint() const;
  void clear_constraint();
  static const int kConstraintFieldNumber = 3;
  const ::operations_research::MPConstraintProto& constraint() const;
  ::operations_research::MPConstraintProto* release_constraint();
  ::operations_research::MPConstraintProto* mutable_constraint();
  void set_allocated_constraint(::operations_research::MPConstraintProto* constraint);

  // optional int32 var_index = 1;
  bool has_var_index() const;
  void clear_var_index();
  static const int kVarIndexFieldNumber = 1;
  ::PROTOBUF_NAMESPACE_ID::int32 var_index() const;
  void set_var_index(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 var_value = 2;
  bool has_var_value() const;
  void clear_var_value();
  static const int kVarValueFieldNumber = 2;
  ::PROTOBUF_NAMESPACE_ID::int32 var_value() const;
  void set_var_value(::PROTOBUF_NAMESPACE_ID::int32 value);

  // @@protoc_insertion_point(class_scope:operations_research.MPIndicatorConstraint)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::operations_research::MPConstraintProto* constraint_;
  ::PROTOBUF_NAMESPACE_ID::int32 var_index_;
  ::PROTOBUF_NAMESPACE_ID::int32 var_value_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------

class MPSosConstraint :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPSosConstraint) */ {
 public:
  MPSosConstraint();
  virtual ~MPSosConstraint();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MPSosConstraint& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MPSosConstraint* internal_default_instance() {
    return reinterpret_cast<const MPSosConstraint*>(
               &_MPSosConstraint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  void Swap(MPSosConstraint* other);
  friend void swap(MPSosConstraint& a, MPSosConstraint& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline MPSosConstraint* New() const final {
    return CreateMaybeMessage<MPSosConstraint>(nullptr);
  }

  MPSosConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MPSosConstraint>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MPSosConstraint& from);
  void MergeFrom(const MPSosConstraint& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPSosConstraint* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPSosConstraint";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
    return ::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // 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(const std::string& name,
      Type* value) {
    return MPSosConstraint_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // repeated int32 var_index = 2;
  int var_index_size() const;
  void clear_var_index();
  static const int kVarIndexFieldNumber = 2;
  ::PROTOBUF_NAMESPACE_ID::int32 var_index(int index) const;
  void set_var_index(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
  void add_var_index(::PROTOBUF_NAMESPACE_ID::int32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      var_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      mutable_var_index();

  // repeated double weight = 3;
  int weight_size() const;
  void clear_weight();
  static const int kWeightFieldNumber = 3;
  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;
  void clear_type();
  static const int kTypeFieldNumber = 1;
  ::operations_research::MPSosConstraint_Type type() const;
  void set_type(::operations_research::MPSosConstraint_Type value);

  // @@protoc_insertion_point(class_scope:operations_research.MPSosConstraint)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > var_index_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > weight_;
  int type_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------

class PartialVariableAssignment :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.PartialVariableAssignment) */ {
 public:
  PartialVariableAssignment();
  virtual ~PartialVariableAssignment();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PartialVariableAssignment& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PartialVariableAssignment* internal_default_instance() {
    return reinterpret_cast<const PartialVariableAssignment*>(
               &_PartialVariableAssignment_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  void Swap(PartialVariableAssignment* other);
  friend void swap(PartialVariableAssignment& a, PartialVariableAssignment& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline PartialVariableAssignment* New() const final {
    return CreateMaybeMessage<PartialVariableAssignment>(nullptr);
  }

  PartialVariableAssignment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartialVariableAssignment>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartialVariableAssignment& from);
  void MergeFrom(const PartialVariableAssignment& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartialVariableAssignment* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.PartialVariableAssignment";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
    return ::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 var_index = 1 [packed = true];
  int var_index_size() const;
  void clear_var_index();
  static const int kVarIndexFieldNumber = 1;
  ::PROTOBUF_NAMESPACE_ID::int32 var_index(int index) const;
  void set_var_index(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
  void add_var_index(::PROTOBUF_NAMESPACE_ID::int32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      var_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      mutable_var_index();

  // repeated double var_value = 2 [packed = true];
  int var_value_size() const;
  void clear_var_value();
  static const int kVarValueFieldNumber = 2;
  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 HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > var_index_;
  mutable std::atomic<int> _var_index_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > var_value_;
  mutable std::atomic<int> _var_value_cached_byte_size_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------

class MPModelProto :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPModelProto) */ {
 public:
  MPModelProto();
  virtual ~MPModelProto();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MPModelProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MPModelProto* internal_default_instance() {
    return reinterpret_cast<const MPModelProto*>(
               &_MPModelProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  void Swap(MPModelProto* other);
  friend void swap(MPModelProto& a, MPModelProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline MPModelProto* New() const final {
    return CreateMaybeMessage<MPModelProto>(nullptr);
  }

  MPModelProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MPModelProto>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MPModelProto& from);
  void MergeFrom(const MPModelProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPModelProto* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPModelProto";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
    return ::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .operations_research.MPVariableProto variable = 3;
  int variable_size() const;
  void clear_variable();
  static const int kVariableFieldNumber = 3;
  ::operations_research::MPVariableProto* mutable_variable(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPVariableProto >*
      mutable_variable();
  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;
  void clear_constraint();
  static const int kConstraintFieldNumber = 4;
  ::operations_research::MPConstraintProto* mutable_constraint(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPConstraintProto >*
      mutable_constraint();
  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;
  void clear_general_constraint();
  static const int kGeneralConstraintFieldNumber = 7;
  ::operations_research::MPGeneralConstraintProto* mutable_general_constraint(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::MPGeneralConstraintProto >*
      mutable_general_constraint();
  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;
  void clear_name();
  static const int kNameFieldNumber = 5;
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // optional .operations_research.PartialVariableAssignment solution_hint = 6;
  bool has_solution_hint() const;
  void clear_solution_hint();
  static const int kSolutionHintFieldNumber = 6;
  const ::operations_research::PartialVariableAssignment& solution_hint() const;
  ::operations_research::PartialVariableAssignment* release_solution_hint();
  ::operations_research::PartialVariableAssignment* mutable_solution_hint();
  void set_allocated_solution_hint(::operations_research::PartialVariableAssignment* solution_hint);

  // optional double objective_offset = 2 [default = 0];
  bool has_objective_offset() const;
  void clear_objective_offset();
  static const int kObjectiveOffsetFieldNumber = 2;
  double objective_offset() const;
  void set_objective_offset(double value);

  // optional bool maximize = 1 [default = false];
  bool has_maximize() const;
  void clear_maximize();
  static const int kMaximizeFieldNumber = 1;
  bool maximize() const;
  void set_maximize(bool value);

  // @@protoc_insertion_point(class_scope:operations_research.MPModelProto)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::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_;
  double objective_offset_;
  bool maximize_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------

class OptionalDouble :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.OptionalDouble) */ {
 public:
  OptionalDouble();
  virtual ~OptionalDouble();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const OptionalDouble& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const OptionalDouble* internal_default_instance() {
    return reinterpret_cast<const OptionalDouble*>(
               &_OptionalDouble_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  void Swap(OptionalDouble* other);
  friend void swap(OptionalDouble& a, OptionalDouble& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline OptionalDouble* New() const final {
    return CreateMaybeMessage<OptionalDouble>(nullptr);
  }

  OptionalDouble* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OptionalDouble>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const OptionalDouble& from);
  void MergeFrom(const OptionalDouble& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OptionalDouble* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.OptionalDouble";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
    return ::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional double value = 1;
  bool has_value() const;
  void clear_value();
  static const int kValueFieldNumber = 1;
  double value() const;
  void set_value(double value);

  // @@protoc_insertion_point(class_scope:operations_research.OptionalDouble)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::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 :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPSolverCommonParameters) */ {
 public:
  MPSolverCommonParameters();
  virtual ~MPSolverCommonParameters();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MPSolverCommonParameters& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MPSolverCommonParameters* internal_default_instance() {
    return reinterpret_cast<const MPSolverCommonParameters*>(
               &_MPSolverCommonParameters_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  void Swap(MPSolverCommonParameters* other);
  friend void swap(MPSolverCommonParameters& a, MPSolverCommonParameters& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline MPSolverCommonParameters* New() const final {
    return CreateMaybeMessage<MPSolverCommonParameters>(nullptr);
  }

  MPSolverCommonParameters* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MPSolverCommonParameters>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MPSolverCommonParameters& from);
  void MergeFrom(const MPSolverCommonParameters& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPSolverCommonParameters* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPSolverCommonParameters";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
    return ::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // 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(const std::string& name,
      LPAlgorithmValues* value) {
    return MPSolverCommonParameters_LPAlgorithmValues_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional .operations_research.OptionalDouble relative_mip_gap = 1;
  bool has_relative_mip_gap() const;
  void clear_relative_mip_gap();
  static const int kRelativeMipGapFieldNumber = 1;
  const ::operations_research::OptionalDouble& relative_mip_gap() const;
  ::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);

  // optional .operations_research.OptionalDouble primal_tolerance = 2;
  bool has_primal_tolerance() const;
  void clear_primal_tolerance();
  static const int kPrimalToleranceFieldNumber = 2;
  const ::operations_research::OptionalDouble& primal_tolerance() const;
  ::operations_research::OptionalDouble* release_primal_tolerance();
  ::operations_research::OptionalDouble* mutable_primal_tolerance();
  void set_allocated_primal_tolerance(::operations_research::OptionalDouble* primal_tolerance);

  // optional .operations_research.OptionalDouble dual_tolerance = 3;
  bool has_dual_tolerance() const;
  void clear_dual_tolerance();
  static const int kDualToleranceFieldNumber = 3;
  const ::operations_research::OptionalDouble& dual_tolerance() const;
  ::operations_research::OptionalDouble* release_dual_tolerance();
  ::operations_research::OptionalDouble* mutable_dual_tolerance();
  void set_allocated_dual_tolerance(::operations_research::OptionalDouble* dual_tolerance);

  // optional .operations_research.MPSolverCommonParameters.LPAlgorithmValues lp_algorithm = 4 [default = LP_ALGO_UNSPECIFIED];
  bool has_lp_algorithm() const;
  void clear_lp_algorithm();
  static const int kLpAlgorithmFieldNumber = 4;
  ::operations_research::MPSolverCommonParameters_LPAlgorithmValues lp_algorithm() const;
  void set_lp_algorithm(::operations_research::MPSolverCommonParameters_LPAlgorithmValues value);

  // optional .operations_research.OptionalBoolean presolve = 5 [default = BOOL_UNSPECIFIED];
  bool has_presolve() const;
  void clear_presolve();
  static const int kPresolveFieldNumber = 5;
  ::operations_research::OptionalBoolean presolve() const;
  void set_presolve(::operations_research::OptionalBoolean value);

  // optional .operations_research.OptionalBoolean scaling = 7 [default = BOOL_UNSPECIFIED];
  bool has_scaling() const;
  void clear_scaling();
  static const int kScalingFieldNumber = 7;
  ::operations_research::OptionalBoolean scaling() const;
  void set_scaling(::operations_research::OptionalBoolean value);

  // @@protoc_insertion_point(class_scope:operations_research.MPSolverCommonParameters)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::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 MPModelRequest :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPModelRequest) */ {
 public:
  MPModelRequest();
  virtual ~MPModelRequest();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MPModelRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MPModelRequest* internal_default_instance() {
    return reinterpret_cast<const MPModelRequest*>(
               &_MPModelRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  void Swap(MPModelRequest* other);
  friend void swap(MPModelRequest& a, MPModelRequest& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline MPModelRequest* New() const final {
    return CreateMaybeMessage<MPModelRequest>(nullptr);
  }

  MPModelRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MPModelRequest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MPModelRequest& from);
  void MergeFrom(const MPModelRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPModelRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPModelRequest";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
    return ::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // 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 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 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(const std::string& name,
      SolverType* value) {
    return MPModelRequest_SolverType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional string solver_specific_parameters = 5;
  bool has_solver_specific_parameters() const;
  void clear_solver_specific_parameters();
  static const int kSolverSpecificParametersFieldNumber = 5;
  const std::string& solver_specific_parameters() const;
  void set_solver_specific_parameters(const std::string& value);
  void set_solver_specific_parameters(std::string&& value);
  void set_solver_specific_parameters(const char* value);
  void set_solver_specific_parameters(const char* value, size_t size);
  std::string* mutable_solver_specific_parameters();
  std::string* release_solver_specific_parameters();
  void set_allocated_solver_specific_parameters(std::string* solver_specific_parameters);

  // optional .operations_research.MPModelProto model = 1;
  bool has_model() const;
  void clear_model();
  static const int kModelFieldNumber = 1;
  const ::operations_research::MPModelProto& model() const;
  ::operations_research::MPModelProto* release_model();
  ::operations_research::MPModelProto* mutable_model();
  void set_allocated_model(::operations_research::MPModelProto* model);

  // optional double solver_time_limit_seconds = 3;
  bool has_solver_time_limit_seconds() const;
  void clear_solver_time_limit_seconds();
  static const int kSolverTimeLimitSecondsFieldNumber = 3;
  double solver_time_limit_seconds() const;
  void set_solver_time_limit_seconds(double value);

  // optional bool enable_internal_solver_output = 4 [default = false];
  bool has_enable_internal_solver_output() const;
  void clear_enable_internal_solver_output();
  static const int kEnableInternalSolverOutputFieldNumber = 4;
  bool enable_internal_solver_output() const;
  void set_enable_internal_solver_output(bool value);

  // optional .operations_research.MPModelRequest.SolverType solver_type = 2;
  bool has_solver_type() const;
  void clear_solver_type();
  static const int kSolverTypeFieldNumber = 2;
  ::operations_research::MPModelRequest_SolverType solver_type() const;
  void set_solver_type(::operations_research::MPModelRequest_SolverType value);

  // @@protoc_insertion_point(class_scope:operations_research.MPModelRequest)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::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_;
  double solver_time_limit_seconds_;
  bool enable_internal_solver_output_;
  int solver_type_;
  friend struct ::TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
};
// -------------------------------------------------------------------

class MPSolutionResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.MPSolutionResponse) */ {
 public:
  MPSolutionResponse();
  virtual ~MPSolutionResponse();

  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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MPSolutionResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MPSolutionResponse* internal_default_instance() {
    return reinterpret_cast<const MPSolutionResponse*>(
               &_MPSolutionResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  void Swap(MPSolutionResponse* other);
  friend void swap(MPSolutionResponse& a, MPSolutionResponse& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline MPSolutionResponse* New() const final {
    return CreateMaybeMessage<MPSolutionResponse>(nullptr);
  }

  MPSolutionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MPSolutionResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MPSolutionResponse& from);
  void MergeFrom(const MPSolutionResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPSolutionResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.MPSolutionResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
    return ::descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated double variable_value = 3 [packed = true];
  int variable_value_size() const;
  void clear_variable_value();
  static const int kVariableValueFieldNumber = 3;
  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;
  void clear_dual_value();
  static const int kDualValueFieldNumber = 4;
  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;
  void clear_reduced_cost();
  static const int kReducedCostFieldNumber = 6;
  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();

  // optional double objective_value = 2;
  bool has_objective_value() const;
  void clear_objective_value();
  static const int kObjectiveValueFieldNumber = 2;
  double objective_value() const;
  void set_objective_value(double value);

  // optional double best_objective_bound = 5;
  bool has_best_objective_bound() const;
  void clear_best_objective_bound();
  static const int kBestObjectiveBoundFieldNumber = 5;
  double best_objective_bound() const;
  void set_best_objective_bound(double value);

  // optional .operations_research.MPSolverResponseStatus status = 1 [default = MPSOLVER_UNKNOWN_STATUS];
  bool has_status() const;
  void clear_status();
  static const int kStatusFieldNumber = 1;
  ::operations_research::MPSolverResponseStatus status() const;
  void set_status(::operations_research::MPSolverResponseStatus value);

  // @@protoc_insertion_point(class_scope:operations_research.MPSolutionResponse)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > variable_value_;
  mutable std::atomic<int> _variable_value_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > dual_value_;
  mutable std::atomic<int> _dual_value_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > reduced_cost_;
  mutable std::atomic<int> _reduced_cost_cached_byte_size_;
  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::has_lower_bound() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void MPVariableProto::clear_lower_bound() {
  lower_bound_ = -std::numeric_limits<double>::infinity();
  _has_bits_[0] &= ~0x00000010u;
}
inline double MPVariableProto::lower_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.lower_bound)
  return lower_bound_;
}
inline void MPVariableProto::set_lower_bound(double value) {
  _has_bits_[0] |= 0x00000010u;
  lower_bound_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.lower_bound)
}

// optional double upper_bound = 2 [default = inf];
inline bool MPVariableProto::has_upper_bound() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void MPVariableProto::clear_upper_bound() {
  upper_bound_ = std::numeric_limits<double>::infinity();
  _has_bits_[0] &= ~0x00000020u;
}
inline double MPVariableProto::upper_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.upper_bound)
  return upper_bound_;
}
inline void MPVariableProto::set_upper_bound(double value) {
  _has_bits_[0] |= 0x00000020u;
  upper_bound_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.upper_bound)
}

// optional double objective_coefficient = 3 [default = 0];
inline bool MPVariableProto::has_objective_coefficient() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MPVariableProto::clear_objective_coefficient() {
  objective_coefficient_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline double MPVariableProto::objective_coefficient() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.objective_coefficient)
  return objective_coefficient_;
}
inline void MPVariableProto::set_objective_coefficient(double value) {
  _has_bits_[0] |= 0x00000002u;
  objective_coefficient_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.objective_coefficient)
}

// optional bool is_integer = 4 [default = false];
inline bool MPVariableProto::has_is_integer() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MPVariableProto::clear_is_integer() {
  is_integer_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool MPVariableProto::is_integer() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.is_integer)
  return is_integer_;
}
inline void MPVariableProto::set_is_integer(bool value) {
  _has_bits_[0] |= 0x00000004u;
  is_integer_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.is_integer)
}

// optional string name = 5 [default = ""];
inline bool MPVariableProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MPVariableProto::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MPVariableProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.name)
  return name_.GetNoArena();
}
inline void MPVariableProto::set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.name)
}
inline void MPVariableProto::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:operations_research.MPVariableProto.name)
}
inline void MPVariableProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:operations_research.MPVariableProto.name)
}
inline void MPVariableProto::set_name(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:operations_research.MPVariableProto.name)
}
inline std::string* MPVariableProto::mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:operations_research.MPVariableProto.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MPVariableProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.MPVariableProto.name)
  if (!has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MPVariableProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPVariableProto.name)
}

// optional int32 branching_priority = 6 [default = 0];
inline bool MPVariableProto::has_branching_priority() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MPVariableProto::clear_branching_priority() {
  branching_priority_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MPVariableProto::branching_priority() const {
  // @@protoc_insertion_point(field_get:operations_research.MPVariableProto.branching_priority)
  return branching_priority_;
}
inline void MPVariableProto::set_branching_priority(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  branching_priority_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPVariableProto.branching_priority)
}

// -------------------------------------------------------------------

// MPConstraintProto

// repeated int32 var_index = 6 [packed = true];
inline int MPConstraintProto::var_index_size() const {
  return var_index_.size();
}
inline void MPConstraintProto::clear_var_index() {
  var_index_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MPConstraintProto::var_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.var_index)
  return var_index_.Get(index);
}
inline void MPConstraintProto::set_var_index(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
  var_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPConstraintProto.var_index)
}
inline void MPConstraintProto::add_var_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
  var_index_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.MPConstraintProto.var_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
MPConstraintProto::var_index() const {
  // @@protoc_insertion_point(field_list:operations_research.MPConstraintProto.var_index)
  return var_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
MPConstraintProto::mutable_var_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPConstraintProto.var_index)
  return &var_index_;
}

// repeated double coefficient = 7 [packed = true];
inline int MPConstraintProto::coefficient_size() const {
  return coefficient_.size();
}
inline void MPConstraintProto::clear_coefficient() {
  coefficient_.Clear();
}
inline double MPConstraintProto::coefficient(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.coefficient)
  return coefficient_.Get(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::add_coefficient(double value) {
  coefficient_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.MPConstraintProto.coefficient)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPConstraintProto::coefficient() const {
  // @@protoc_insertion_point(field_list:operations_research.MPConstraintProto.coefficient)
  return coefficient_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPConstraintProto::mutable_coefficient() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPConstraintProto.coefficient)
  return &coefficient_;
}

// optional double lower_bound = 2 [default = -inf];
inline bool MPConstraintProto::has_lower_bound() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MPConstraintProto::clear_lower_bound() {
  lower_bound_ = -std::numeric_limits<double>::infinity();
  _has_bits_[0] &= ~0x00000004u;
}
inline double MPConstraintProto::lower_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.lower_bound)
  return lower_bound_;
}
inline void MPConstraintProto::set_lower_bound(double value) {
  _has_bits_[0] |= 0x00000004u;
  lower_bound_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPConstraintProto.lower_bound)
}

// optional double upper_bound = 3 [default = inf];
inline bool MPConstraintProto::has_upper_bound() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MPConstraintProto::clear_upper_bound() {
  upper_bound_ = std::numeric_limits<double>::infinity();
  _has_bits_[0] &= ~0x00000008u;
}
inline double MPConstraintProto::upper_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.upper_bound)
  return upper_bound_;
}
inline void MPConstraintProto::set_upper_bound(double value) {
  _has_bits_[0] |= 0x00000008u;
  upper_bound_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPConstraintProto.upper_bound)
}

// optional string name = 4 [default = ""];
inline bool MPConstraintProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MPConstraintProto::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MPConstraintProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.name)
  return name_.GetNoArena();
}
inline void MPConstraintProto::set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:operations_research.MPConstraintProto.name)
}
inline void MPConstraintProto::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:operations_research.MPConstraintProto.name)
}
inline void MPConstraintProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:operations_research.MPConstraintProto.name)
}
inline void MPConstraintProto::set_name(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:operations_research.MPConstraintProto.name)
}
inline std::string* MPConstraintProto::mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:operations_research.MPConstraintProto.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MPConstraintProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.MPConstraintProto.name)
  if (!has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MPConstraintProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPConstraintProto.name)
}

// optional bool is_lazy = 5 [default = false];
inline bool MPConstraintProto::has_is_lazy() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MPConstraintProto::clear_is_lazy() {
  is_lazy_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool MPConstraintProto::is_lazy() const {
  // @@protoc_insertion_point(field_get:operations_research.MPConstraintProto.is_lazy)
  return is_lazy_;
}
inline void MPConstraintProto::set_is_lazy(bool value) {
  _has_bits_[0] |= 0x00000002u;
  is_lazy_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPConstraintProto.is_lazy)
}

// -------------------------------------------------------------------

// MPGeneralConstraintProto

// optional string name = 1 [default = ""];
inline bool MPGeneralConstraintProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MPGeneralConstraintProto::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MPGeneralConstraintProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.name)
  return name_.GetNoArena();
}
inline void MPGeneralConstraintProto::set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:operations_research.MPGeneralConstraintProto.name)
}
inline void MPGeneralConstraintProto::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:operations_research.MPGeneralConstraintProto.name)
}
inline void MPGeneralConstraintProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:operations_research.MPGeneralConstraintProto.name)
}
inline void MPGeneralConstraintProto::set_name(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:operations_research.MPGeneralConstraintProto.name)
}
inline std::string* MPGeneralConstraintProto::mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MPGeneralConstraintProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.MPGeneralConstraintProto.name)
  if (!has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MPGeneralConstraintProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPGeneralConstraintProto.name)
}

// optional .operations_research.MPIndicatorConstraint indicator_constraint = 2;
inline bool MPGeneralConstraintProto::has_indicator_constraint() const {
  return general_constraint_case() == kIndicatorConstraint;
}
inline void MPGeneralConstraintProto::set_has_indicator_constraint() {
  _oneof_case_[0] = kIndicatorConstraint;
}
inline void MPGeneralConstraintProto::clear_indicator_constraint() {
  if (has_indicator_constraint()) {
    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 (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 const ::operations_research::MPIndicatorConstraint& MPGeneralConstraintProto::indicator_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.indicator_constraint)
  return has_indicator_constraint()
      ? *general_constraint_.indicator_constraint_
      : *reinterpret_cast< ::operations_research::MPIndicatorConstraint*>(&::operations_research::_MPIndicatorConstraint_default_instance_);
}
inline ::operations_research::MPIndicatorConstraint* MPGeneralConstraintProto::mutable_indicator_constraint() {
  if (!has_indicator_constraint()) {
    clear_general_constraint();
    set_has_indicator_constraint();
    general_constraint_.indicator_constraint_ = CreateMaybeMessage< ::operations_research::MPIndicatorConstraint >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.indicator_constraint)
  return general_constraint_.indicator_constraint_;
}

// optional .operations_research.MPSosConstraint sos_constraint = 3;
inline bool MPGeneralConstraintProto::has_sos_constraint() const {
  return general_constraint_case() == kSosConstraint;
}
inline void MPGeneralConstraintProto::set_has_sos_constraint() {
  _oneof_case_[0] = kSosConstraint;
}
inline void MPGeneralConstraintProto::clear_sos_constraint() {
  if (has_sos_constraint()) {
    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 (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 const ::operations_research::MPSosConstraint& MPGeneralConstraintProto::sos_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.MPGeneralConstraintProto.sos_constraint)
  return has_sos_constraint()
      ? *general_constraint_.sos_constraint_
      : *reinterpret_cast< ::operations_research::MPSosConstraint*>(&::operations_research::_MPSosConstraint_default_instance_);
}
inline ::operations_research::MPSosConstraint* MPGeneralConstraintProto::mutable_sos_constraint() {
  if (!has_sos_constraint()) {
    clear_general_constraint();
    set_has_sos_constraint();
    general_constraint_.sos_constraint_ = CreateMaybeMessage< ::operations_research::MPSosConstraint >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.MPGeneralConstraintProto.sos_constraint)
  return general_constraint_.sos_constraint_;
}

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::has_var_index() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MPIndicatorConstraint::clear_var_index() {
  var_index_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MPIndicatorConstraint::var_index() const {
  // @@protoc_insertion_point(field_get:operations_research.MPIndicatorConstraint.var_index)
  return var_index_;
}
inline void MPIndicatorConstraint::set_var_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  var_index_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPIndicatorConstraint.var_index)
}

// optional int32 var_value = 2;
inline bool MPIndicatorConstraint::has_var_value() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MPIndicatorConstraint::clear_var_value() {
  var_value_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MPIndicatorConstraint::var_value() const {
  // @@protoc_insertion_point(field_get:operations_research.MPIndicatorConstraint.var_value)
  return var_value_;
}
inline void MPIndicatorConstraint::set_var_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  var_value_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPIndicatorConstraint.var_value)
}

// optional .operations_research.MPConstraintProto constraint = 3;
inline bool MPIndicatorConstraint::has_constraint() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MPIndicatorConstraint::clear_constraint() {
  if (constraint_ != nullptr) constraint_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::operations_research::MPConstraintProto& MPIndicatorConstraint::constraint() const {
  const ::operations_research::MPConstraintProto* p = constraint_;
  // @@protoc_insertion_point(field_get:operations_research.MPIndicatorConstraint.constraint)
  return p != nullptr ? *p : *reinterpret_cast<const ::operations_research::MPConstraintProto*>(
      &::operations_research::_MPConstraintProto_default_instance_);
}
inline ::operations_research::MPConstraintProto* MPIndicatorConstraint::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::mutable_constraint() {
  _has_bits_[0] |= 0x00000001u;
  if (constraint_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::MPConstraintProto>(GetArenaNoVirtual());
    constraint_ = p;
  }
  // @@protoc_insertion_point(field_mutable:operations_research.MPIndicatorConstraint.constraint)
  return constraint_;
}
inline void MPIndicatorConstraint::set_allocated_constraint(::operations_research::MPConstraintProto* constraint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete constraint_;
  }
  if (constraint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    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::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MPSosConstraint::clear_type() {
  type_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::operations_research::MPSosConstraint_Type MPSosConstraint::type() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSosConstraint.type)
  return static_cast< ::operations_research::MPSosConstraint_Type >(type_);
}
inline void MPSosConstraint::set_type(::operations_research::MPSosConstraint_Type value) {
  assert(::operations_research::MPSosConstraint_Type_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  type_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPSosConstraint.type)
}

// repeated int32 var_index = 2;
inline int MPSosConstraint::var_index_size() const {
  return var_index_.size();
}
inline void MPSosConstraint::clear_var_index() {
  var_index_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MPSosConstraint::var_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSosConstraint.var_index)
  return var_index_.Get(index);
}
inline void MPSosConstraint::set_var_index(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
  var_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.MPSosConstraint.var_index)
}
inline void MPSosConstraint::add_var_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
  var_index_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.MPSosConstraint.var_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
MPSosConstraint::var_index() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSosConstraint.var_index)
  return var_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
MPSosConstraint::mutable_var_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPSosConstraint.var_index)
  return &var_index_;
}

// repeated double weight = 3;
inline int MPSosConstraint::weight_size() const {
  return weight_.size();
}
inline void MPSosConstraint::clear_weight() {
  weight_.Clear();
}
inline double MPSosConstraint::weight(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSosConstraint.weight)
  return weight_.Get(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::add_weight(double value) {
  weight_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.MPSosConstraint.weight)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSosConstraint::weight() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSosConstraint.weight)
  return weight_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
MPSosConstraint::mutable_weight() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.MPSosConstraint.weight)
  return &weight_;
}

// -------------------------------------------------------------------

// PartialVariableAssignment

// repeated int32 var_index = 1 [packed = true];
inline int PartialVariableAssignment::var_index_size() const {
  return var_index_.size();
}
inline void PartialVariableAssignment::clear_var_index() {
  var_index_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartialVariableAssignment::var_index(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.PartialVariableAssignment.var_index)
  return var_index_.Get(index);
}
inline void PartialVariableAssignment::set_var_index(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
  var_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.PartialVariableAssignment.var_index)
}
inline void PartialVariableAssignment::add_var_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
  var_index_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.PartialVariableAssignment.var_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
PartialVariableAssignment::var_index() const {
  // @@protoc_insertion_point(field_list:operations_research.PartialVariableAssignment.var_index)
  return var_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
PartialVariableAssignment::mutable_var_index() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.PartialVariableAssignment.var_index)
  return &var_index_;
}

// repeated double var_value = 2 [packed = true];
inline int PartialVariableAssignment::var_value_size() const {
  return var_value_.size();
}
inline void PartialVariableAssignment::clear_var_value() {
  var_value_.Clear();
}
inline double PartialVariableAssignment::var_value(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.PartialVariableAssignment.var_value)
  return var_value_.Get(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::add_var_value(double value) {
  var_value_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.PartialVariableAssignment.var_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
PartialVariableAssignment::var_value() const {
  // @@protoc_insertion_point(field_list:operations_research.PartialVariableAssignment.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 &var_value_;
}

// -------------------------------------------------------------------

// MPModelProto

// optional bool maximize = 1 [default = false];
inline bool MPModelProto::has_maximize() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MPModelProto::clear_maximize() {
  maximize_ = false;
  _has_bits_[0] &= ~0x00000008u;
}
inline bool MPModelProto::maximize() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.maximize)
  return maximize_;
}
inline void MPModelProto::set_maximize(bool value) {
  _has_bits_[0] |= 0x00000008u;
  maximize_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPModelProto.maximize)
}

// optional double objective_offset = 2 [default = 0];
inline bool MPModelProto::has_objective_offset() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MPModelProto::clear_objective_offset() {
  objective_offset_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline double MPModelProto::objective_offset() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.objective_offset)
  return objective_offset_;
}
inline void MPModelProto::set_objective_offset(double value) {
  _has_bits_[0] |= 0x00000004u;
  objective_offset_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPModelProto.objective_offset)
}

// repeated .operations_research.MPVariableProto variable = 3;
inline int MPModelProto::variable_size() const {
  return 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::variable(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.variable)
  return variable_.Get(index);
}
inline ::operations_research::MPVariableProto* MPModelProto::add_variable() {
  // @@protoc_insertion_point(field_add:operations_research.MPModelProto.variable)
  return variable_.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::constraint_size() const {
  return 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::constraint(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.constraint)
  return constraint_.Get(index);
}
inline ::operations_research::MPConstraintProto* MPModelProto::add_constraint() {
  // @@protoc_insertion_point(field_add:operations_research.MPModelProto.constraint)
  return constraint_.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::general_constraint_size() const {
  return 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::general_constraint(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.general_constraint)
  return general_constraint_.Get(index);
}
inline ::operations_research::MPGeneralConstraintProto* MPModelProto::add_general_constraint() {
  // @@protoc_insertion_point(field_add:operations_research.MPModelProto.general_constraint)
  return general_constraint_.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 string name = 5 [default = ""];
inline bool MPModelProto::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MPModelProto::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MPModelProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.name)
  return name_.GetNoArena();
}
inline void MPModelProto::set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:operations_research.MPModelProto.name)
}
inline void MPModelProto::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:operations_research.MPModelProto.name)
}
inline void MPModelProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:operations_research.MPModelProto.name)
}
inline void MPModelProto::set_name(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:operations_research.MPModelProto.name)
}
inline std::string* MPModelProto::mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelProto.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MPModelProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.MPModelProto.name)
  if (!has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MPModelProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPModelProto.name)
}

// optional .operations_research.PartialVariableAssignment solution_hint = 6;
inline bool MPModelProto::has_solution_hint() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MPModelProto::clear_solution_hint() {
  if (solution_hint_ != nullptr) solution_hint_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::operations_research::PartialVariableAssignment& MPModelProto::solution_hint() const {
  const ::operations_research::PartialVariableAssignment* p = solution_hint_;
  // @@protoc_insertion_point(field_get:operations_research.MPModelProto.solution_hint)
  return p != nullptr ? *p : *reinterpret_cast<const ::operations_research::PartialVariableAssignment*>(
      &::operations_research::_PartialVariableAssignment_default_instance_);
}
inline ::operations_research::PartialVariableAssignment* MPModelProto::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::mutable_solution_hint() {
  _has_bits_[0] |= 0x00000002u;
  if (solution_hint_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::PartialVariableAssignment>(GetArenaNoVirtual());
    solution_hint_ = p;
  }
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelProto.solution_hint)
  return solution_hint_;
}
inline void MPModelProto::set_allocated_solution_hint(::operations_research::PartialVariableAssignment* solution_hint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete solution_hint_;
  }
  if (solution_hint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    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::has_value() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OptionalDouble::clear_value() {
  value_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline double OptionalDouble::value() const {
  // @@protoc_insertion_point(field_get:operations_research.OptionalDouble.value)
  return value_;
}
inline void OptionalDouble::set_value(double value) {
  _has_bits_[0] |= 0x00000001u;
  value_ = value;
  // @@protoc_insertion_point(field_set:operations_research.OptionalDouble.value)
}

// -------------------------------------------------------------------

// MPSolverCommonParameters

// optional .operations_research.OptionalDouble relative_mip_gap = 1;
inline bool MPSolverCommonParameters::has_relative_mip_gap() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
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::relative_mip_gap() const {
  const ::operations_research::OptionalDouble* p = relative_mip_gap_;
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.relative_mip_gap)
  return p != nullptr ? *p : *reinterpret_cast<const ::operations_research::OptionalDouble*>(
      &::operations_research::_OptionalDouble_default_instance_);
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::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::mutable_relative_mip_gap() {
  _has_bits_[0] |= 0x00000001u;
  if (relative_mip_gap_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::OptionalDouble>(GetArenaNoVirtual());
    relative_mip_gap_ = p;
  }
  // @@protoc_insertion_point(field_mutable:operations_research.MPSolverCommonParameters.relative_mip_gap)
  return relative_mip_gap_;
}
inline void MPSolverCommonParameters::set_allocated_relative_mip_gap(::operations_research::OptionalDouble* relative_mip_gap) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete relative_mip_gap_;
  }
  if (relative_mip_gap) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    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::has_primal_tolerance() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MPSolverCommonParameters::clear_primal_tolerance() {
  if (primal_tolerance_ != nullptr) primal_tolerance_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::operations_research::OptionalDouble& MPSolverCommonParameters::primal_tolerance() const {
  const ::operations_research::OptionalDouble* p = primal_tolerance_;
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.primal_tolerance)
  return p != nullptr ? *p : *reinterpret_cast<const ::operations_research::OptionalDouble*>(
      &::operations_research::_OptionalDouble_default_instance_);
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::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::mutable_primal_tolerance() {
  _has_bits_[0] |= 0x00000002u;
  if (primal_tolerance_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::OptionalDouble>(GetArenaNoVirtual());
    primal_tolerance_ = p;
  }
  // @@protoc_insertion_point(field_mutable:operations_research.MPSolverCommonParameters.primal_tolerance)
  return primal_tolerance_;
}
inline void MPSolverCommonParameters::set_allocated_primal_tolerance(::operations_research::OptionalDouble* primal_tolerance) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete primal_tolerance_;
  }
  if (primal_tolerance) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    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::has_dual_tolerance() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MPSolverCommonParameters::clear_dual_tolerance() {
  if (dual_tolerance_ != nullptr) dual_tolerance_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::operations_research::OptionalDouble& MPSolverCommonParameters::dual_tolerance() const {
  const ::operations_research::OptionalDouble* p = dual_tolerance_;
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.dual_tolerance)
  return p != nullptr ? *p : *reinterpret_cast<const ::operations_research::OptionalDouble*>(
      &::operations_research::_OptionalDouble_default_instance_);
}
inline ::operations_research::OptionalDouble* MPSolverCommonParameters::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::mutable_dual_tolerance() {
  _has_bits_[0] |= 0x00000004u;
  if (dual_tolerance_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::OptionalDouble>(GetArenaNoVirtual());
    dual_tolerance_ = p;
  }
  // @@protoc_insertion_point(field_mutable:operations_research.MPSolverCommonParameters.dual_tolerance)
  return dual_tolerance_;
}
inline void MPSolverCommonParameters::set_allocated_dual_tolerance(::operations_research::OptionalDouble* dual_tolerance) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete dual_tolerance_;
  }
  if (dual_tolerance) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    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::has_lp_algorithm() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MPSolverCommonParameters::clear_lp_algorithm() {
  lp_algorithm_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::operations_research::MPSolverCommonParameters_LPAlgorithmValues MPSolverCommonParameters::lp_algorithm() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.lp_algorithm)
  return static_cast< ::operations_research::MPSolverCommonParameters_LPAlgorithmValues >(lp_algorithm_);
}
inline void MPSolverCommonParameters::set_lp_algorithm(::operations_research::MPSolverCommonParameters_LPAlgorithmValues value) {
  assert(::operations_research::MPSolverCommonParameters_LPAlgorithmValues_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  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::has_presolve() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void MPSolverCommonParameters::clear_presolve() {
  presolve_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::operations_research::OptionalBoolean MPSolverCommonParameters::presolve() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.presolve)
  return static_cast< ::operations_research::OptionalBoolean >(presolve_);
}
inline void MPSolverCommonParameters::set_presolve(::operations_research::OptionalBoolean value) {
  assert(::operations_research::OptionalBoolean_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  presolve_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPSolverCommonParameters.presolve)
}

// optional .operations_research.OptionalBoolean scaling = 7 [default = BOOL_UNSPECIFIED];
inline bool MPSolverCommonParameters::has_scaling() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void MPSolverCommonParameters::clear_scaling() {
  scaling_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::operations_research::OptionalBoolean MPSolverCommonParameters::scaling() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolverCommonParameters.scaling)
  return static_cast< ::operations_research::OptionalBoolean >(scaling_);
}
inline void MPSolverCommonParameters::set_scaling(::operations_research::OptionalBoolean value) {
  assert(::operations_research::OptionalBoolean_IsValid(value));
  _has_bits_[0] |= 0x00000020u;
  scaling_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPSolverCommonParameters.scaling)
}

// -------------------------------------------------------------------

// MPModelRequest

// optional .operations_research.MPModelProto model = 1;
inline bool MPModelRequest::has_model() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MPModelRequest::clear_model() {
  if (model_ != nullptr) model_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::operations_research::MPModelProto& MPModelRequest::model() const {
  const ::operations_research::MPModelProto* p = model_;
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.model)
  return p != nullptr ? *p : *reinterpret_cast<const ::operations_research::MPModelProto*>(
      &::operations_research::_MPModelProto_default_instance_);
}
inline ::operations_research::MPModelProto* MPModelRequest::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::mutable_model() {
  _has_bits_[0] |= 0x00000002u;
  if (model_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::MPModelProto>(GetArenaNoVirtual());
    model_ = p;
  }
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelRequest.model)
  return model_;
}
inline void MPModelRequest::set_allocated_model(::operations_research::MPModelProto* model) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete model_;
  }
  if (model) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    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::has_solver_type() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void MPModelRequest::clear_solver_type() {
  solver_type_ = 2;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::operations_research::MPModelRequest_SolverType MPModelRequest::solver_type() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.solver_type)
  return static_cast< ::operations_research::MPModelRequest_SolverType >(solver_type_);
}
inline void MPModelRequest::set_solver_type(::operations_research::MPModelRequest_SolverType value) {
  assert(::operations_research::MPModelRequest_SolverType_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  solver_type_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPModelRequest.solver_type)
}

// optional double solver_time_limit_seconds = 3;
inline bool MPModelRequest::has_solver_time_limit_seconds() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MPModelRequest::clear_solver_time_limit_seconds() {
  solver_time_limit_seconds_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline double MPModelRequest::solver_time_limit_seconds() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.solver_time_limit_seconds)
  return solver_time_limit_seconds_;
}
inline void MPModelRequest::set_solver_time_limit_seconds(double value) {
  _has_bits_[0] |= 0x00000004u;
  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::has_enable_internal_solver_output() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MPModelRequest::clear_enable_internal_solver_output() {
  enable_internal_solver_output_ = false;
  _has_bits_[0] &= ~0x00000008u;
}
inline bool MPModelRequest::enable_internal_solver_output() const {
  // @@protoc_insertion_point(field_get:operations_research.MPModelRequest.enable_internal_solver_output)
  return enable_internal_solver_output_;
}
inline void MPModelRequest::set_enable_internal_solver_output(bool value) {
  _has_bits_[0] |= 0x00000008u;
  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::has_solver_specific_parameters() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MPModelRequest::clear_solver_specific_parameters() {
  solver_specific_parameters_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _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 solver_specific_parameters_.GetNoArena();
}
inline void MPModelRequest::set_solver_specific_parameters(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  solver_specific_parameters_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:operations_research.MPModelRequest.solver_specific_parameters)
}
inline void MPModelRequest::set_solver_specific_parameters(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  solver_specific_parameters_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:operations_research.MPModelRequest.solver_specific_parameters)
}
inline void MPModelRequest::set_solver_specific_parameters(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  solver_specific_parameters_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:operations_research.MPModelRequest.solver_specific_parameters)
}
inline void MPModelRequest::set_solver_specific_parameters(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  solver_specific_parameters_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:operations_research.MPModelRequest.solver_specific_parameters)
}
inline std::string* MPModelRequest::mutable_solver_specific_parameters() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:operations_research.MPModelRequest.solver_specific_parameters)
  return solver_specific_parameters_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MPModelRequest::release_solver_specific_parameters() {
  // @@protoc_insertion_point(field_release:operations_research.MPModelRequest.solver_specific_parameters)
  if (!has_solver_specific_parameters()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return solver_specific_parameters_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
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_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), solver_specific_parameters);
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPModelRequest.solver_specific_parameters)
}

// -------------------------------------------------------------------

// MPSolutionResponse

// optional .operations_research.MPSolverResponseStatus status = 1 [default = MPSOLVER_UNKNOWN_STATUS];
inline bool MPSolutionResponse::has_status() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MPSolutionResponse::clear_status() {
  status_ = 99;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::operations_research::MPSolverResponseStatus MPSolutionResponse::status() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.status)
  return static_cast< ::operations_research::MPSolverResponseStatus >(status_);
}
inline void MPSolutionResponse::set_status(::operations_research::MPSolverResponseStatus value) {
  assert(::operations_research::MPSolverResponseStatus_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  status_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPSolutionResponse.status)
}

// optional double objective_value = 2;
inline bool MPSolutionResponse::has_objective_value() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MPSolutionResponse::clear_objective_value() {
  objective_value_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline double MPSolutionResponse::objective_value() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.objective_value)
  return objective_value_;
}
inline void MPSolutionResponse::set_objective_value(double value) {
  _has_bits_[0] |= 0x00000001u;
  objective_value_ = value;
  // @@protoc_insertion_point(field_set:operations_research.MPSolutionResponse.objective_value)
}

// optional double best_objective_bound = 5;
inline bool MPSolutionResponse::has_best_objective_bound() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MPSolutionResponse::clear_best_objective_bound() {
  best_objective_bound_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline double MPSolutionResponse::best_objective_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.best_objective_bound)
  return best_objective_bound_;
}
inline void MPSolutionResponse::set_best_objective_bound(double value) {
  _has_bits_[0] |= 0x00000002u;
  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::variable_value_size() const {
  return variable_value_.size();
}
inline void MPSolutionResponse::clear_variable_value() {
  variable_value_.Clear();
}
inline double MPSolutionResponse::variable_value(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.variable_value)
  return variable_value_.Get(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::add_variable_value(double value) {
  variable_value_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.MPSolutionResponse.variable_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSolutionResponse::variable_value() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSolutionResponse.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 &variable_value_;
}

// repeated double dual_value = 4 [packed = true];
inline int MPSolutionResponse::dual_value_size() const {
  return dual_value_.size();
}
inline void MPSolutionResponse::clear_dual_value() {
  dual_value_.Clear();
}
inline double MPSolutionResponse::dual_value(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.dual_value)
  return dual_value_.Get(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::add_dual_value(double value) {
  dual_value_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.MPSolutionResponse.dual_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSolutionResponse::dual_value() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSolutionResponse.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 &dual_value_;
}

// repeated double reduced_cost = 6 [packed = true];
inline int MPSolutionResponse::reduced_cost_size() const {
  return reduced_cost_.size();
}
inline void MPSolutionResponse::clear_reduced_cost() {
  reduced_cost_.Clear();
}
inline double MPSolutionResponse::reduced_cost(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.MPSolutionResponse.reduced_cost)
  return reduced_cost_.Get(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::add_reduced_cost(double value) {
  reduced_cost_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.MPSolutionResponse.reduced_cost)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
MPSolutionResponse::reduced_cost() const {
  // @@protoc_insertion_point(field_list:operations_research.MPSolutionResponse.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 &reduced_cost_;
}

#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