parameters.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: ortools/glop/parameters.proto
// Protobuf C++ Version: 6.31.1
 
#ifndef ortools_2fglop_2fparameters_2eproto_2epb_2eh
#define ortools_2fglop_2fparameters_2eproto_2epb_2eh
 
#include <limits>
#include <string>
#include <type_traits>
#include <utility>
 
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 6031001
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
// @@protoc_insertion_point(includes)
 
// Must be included last.
#include "google/protobuf/port_def.inc"
 
#define PROTOBUF_INTERNAL_EXPORT_ortools_2fglop_2fparameters_2eproto OR_PROTO_DLL
 
namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
}  // namespace internal
}  // namespace protobuf
}  // namespace google
 
// Internal implementation detail -- do not use these members.
struct OR_PROTO_DLL TableStruct_ortools_2fglop_2fparameters_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
OR_PROTO_DLL extern const ::google::protobuf::internal::DescriptorTable descriptor_table_ortools_2fglop_2fparameters_2eproto;
}  // extern "C"
namespace operations_research {
namespace glop {
enum GlopParameters_CostScalingAlgorithm : int;
OR_PROTO_DLL extern const uint32_t GlopParameters_CostScalingAlgorithm_internal_data_[];
enum GlopParameters_InitialBasisHeuristic : int;
OR_PROTO_DLL extern const uint32_t GlopParameters_InitialBasisHeuristic_internal_data_[];
enum GlopParameters_PricingRule : int;
OR_PROTO_DLL extern const uint32_t GlopParameters_PricingRule_internal_data_[];
enum GlopParameters_ScalingAlgorithm : int;
OR_PROTO_DLL extern const uint32_t GlopParameters_ScalingAlgorithm_internal_data_[];
enum GlopParameters_SolverBehavior : int;
OR_PROTO_DLL extern const uint32_t GlopParameters_SolverBehavior_internal_data_[];
class GlopParameters;
struct GlopParametersDefaultTypeInternal;
OR_PROTO_DLL extern GlopParametersDefaultTypeInternal _GlopParameters_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull GlopParameters_class_data_;
}  // namespace glop
}  // namespace operations_research
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::operations_research::glop::GlopParameters_CostScalingAlgorithm_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_CostScalingAlgorithm>;
template <>
internal::EnumTraitsT<::operations_research::glop::GlopParameters_InitialBasisHeuristic_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_InitialBasisHeuristic>;
template <>
internal::EnumTraitsT<::operations_research::glop::GlopParameters_PricingRule_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_PricingRule>;
template <>
internal::EnumTraitsT<::operations_research::glop::GlopParameters_ScalingAlgorithm_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_ScalingAlgorithm>;
template <>
internal::EnumTraitsT<::operations_research::glop::GlopParameters_SolverBehavior_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_SolverBehavior>;
}  // namespace protobuf
}  // namespace google
 
namespace operations_research {
namespace glop {
enum GlopParameters_ScalingAlgorithm : int {
  GlopParameters_ScalingAlgorithm_DEFAULT = 0,
  GlopParameters_ScalingAlgorithm_EQUILIBRATION = 1,
  GlopParameters_ScalingAlgorithm_LINEAR_PROGRAM = 2,
};
 
OR_PROTO_DLL extern const uint32_t GlopParameters_ScalingAlgorithm_internal_data_[];
inline constexpr GlopParameters_ScalingAlgorithm GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MIN =
    static_cast<GlopParameters_ScalingAlgorithm>(0);
inline constexpr GlopParameters_ScalingAlgorithm GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MAX =
    static_cast<GlopParameters_ScalingAlgorithm>(2);
inline bool GlopParameters_ScalingAlgorithm_IsValid(int value) {
  return 0 <= value && value <= 2;
}
inline constexpr int GlopParameters_ScalingAlgorithm_ScalingAlgorithm_ARRAYSIZE = 2 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL GlopParameters_ScalingAlgorithm_descriptor();
template <typename T>
const ::std::string& GlopParameters_ScalingAlgorithm_Name(T value) {
  static_assert(::std::is_same<T, GlopParameters_ScalingAlgorithm>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to ScalingAlgorithm_Name().");
  return GlopParameters_ScalingAlgorithm_Name(static_cast<GlopParameters_ScalingAlgorithm>(value));
}
template <>
inline const ::std::string& GlopParameters_ScalingAlgorithm_Name(GlopParameters_ScalingAlgorithm value) {
  return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_ScalingAlgorithm_descriptor, 0, 2>(
      static_cast<int>(value));
}
inline bool GlopParameters_ScalingAlgorithm_Parse(
    ::absl::string_view name, GlopParameters_ScalingAlgorithm* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<GlopParameters_ScalingAlgorithm>(GlopParameters_ScalingAlgorithm_descriptor(), name,
                                           value);
}
enum GlopParameters_SolverBehavior : int {
  GlopParameters_SolverBehavior_ALWAYS_DO = 0,
  GlopParameters_SolverBehavior_NEVER_DO = 1,
  GlopParameters_SolverBehavior_LET_SOLVER_DECIDE = 2,
};
 
OR_PROTO_DLL extern const uint32_t GlopParameters_SolverBehavior_internal_data_[];
inline constexpr GlopParameters_SolverBehavior GlopParameters_SolverBehavior_SolverBehavior_MIN =
    static_cast<GlopParameters_SolverBehavior>(0);
inline constexpr GlopParameters_SolverBehavior GlopParameters_SolverBehavior_SolverBehavior_MAX =
    static_cast<GlopParameters_SolverBehavior>(2);
inline bool GlopParameters_SolverBehavior_IsValid(int value) {
  return 0 <= value && value <= 2;
}
inline constexpr int GlopParameters_SolverBehavior_SolverBehavior_ARRAYSIZE = 2 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL GlopParameters_SolverBehavior_descriptor();
template <typename T>
const ::std::string& GlopParameters_SolverBehavior_Name(T value) {
  static_assert(::std::is_same<T, GlopParameters_SolverBehavior>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to SolverBehavior_Name().");
  return GlopParameters_SolverBehavior_Name(static_cast<GlopParameters_SolverBehavior>(value));
}
template <>
inline const ::std::string& GlopParameters_SolverBehavior_Name(GlopParameters_SolverBehavior value) {
  return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_SolverBehavior_descriptor, 0, 2>(
      static_cast<int>(value));
}
inline bool GlopParameters_SolverBehavior_Parse(
    ::absl::string_view name, GlopParameters_SolverBehavior* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<GlopParameters_SolverBehavior>(GlopParameters_SolverBehavior_descriptor(), name,
                                           value);
}
enum GlopParameters_PricingRule : int {
  GlopParameters_PricingRule_DANTZIG = 0,
  GlopParameters_PricingRule_STEEPEST_EDGE = 1,
  GlopParameters_PricingRule_DEVEX = 2,
};
 
OR_PROTO_DLL extern const uint32_t GlopParameters_PricingRule_internal_data_[];
inline constexpr GlopParameters_PricingRule GlopParameters_PricingRule_PricingRule_MIN =
    static_cast<GlopParameters_PricingRule>(0);
inline constexpr GlopParameters_PricingRule GlopParameters_PricingRule_PricingRule_MAX =
    static_cast<GlopParameters_PricingRule>(2);
inline bool GlopParameters_PricingRule_IsValid(int value) {
  return 0 <= value && value <= 2;
}
inline constexpr int GlopParameters_PricingRule_PricingRule_ARRAYSIZE = 2 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL GlopParameters_PricingRule_descriptor();
template <typename T>
const ::std::string& GlopParameters_PricingRule_Name(T value) {
  static_assert(::std::is_same<T, GlopParameters_PricingRule>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to PricingRule_Name().");
  return GlopParameters_PricingRule_Name(static_cast<GlopParameters_PricingRule>(value));
}
template <>
inline const ::std::string& GlopParameters_PricingRule_Name(GlopParameters_PricingRule value) {
  return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_PricingRule_descriptor, 0, 2>(
      static_cast<int>(value));
}
inline bool GlopParameters_PricingRule_Parse(
    ::absl::string_view name, GlopParameters_PricingRule* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<GlopParameters_PricingRule>(GlopParameters_PricingRule_descriptor(), name,
                                           value);
}
enum GlopParameters_InitialBasisHeuristic : int {
  GlopParameters_InitialBasisHeuristic_NONE = 0,
  GlopParameters_InitialBasisHeuristic_BIXBY = 1,
  GlopParameters_InitialBasisHeuristic_TRIANGULAR = 2,
  GlopParameters_InitialBasisHeuristic_MAROS = 3,
};
 
OR_PROTO_DLL extern const uint32_t GlopParameters_InitialBasisHeuristic_internal_data_[];
inline constexpr GlopParameters_InitialBasisHeuristic GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MIN =
    static_cast<GlopParameters_InitialBasisHeuristic>(0);
inline constexpr GlopParameters_InitialBasisHeuristic GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MAX =
    static_cast<GlopParameters_InitialBasisHeuristic>(3);
inline bool GlopParameters_InitialBasisHeuristic_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_ARRAYSIZE = 3 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL GlopParameters_InitialBasisHeuristic_descriptor();
template <typename T>
const ::std::string& GlopParameters_InitialBasisHeuristic_Name(T value) {
  static_assert(::std::is_same<T, GlopParameters_InitialBasisHeuristic>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to InitialBasisHeuristic_Name().");
  return GlopParameters_InitialBasisHeuristic_Name(static_cast<GlopParameters_InitialBasisHeuristic>(value));
}
template <>
inline const ::std::string& GlopParameters_InitialBasisHeuristic_Name(GlopParameters_InitialBasisHeuristic value) {
  return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_InitialBasisHeuristic_descriptor, 0, 3>(
      static_cast<int>(value));
}
inline bool GlopParameters_InitialBasisHeuristic_Parse(
    ::absl::string_view name, GlopParameters_InitialBasisHeuristic* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<GlopParameters_InitialBasisHeuristic>(GlopParameters_InitialBasisHeuristic_descriptor(), name,
                                           value);
}
enum GlopParameters_CostScalingAlgorithm : int {
  GlopParameters_CostScalingAlgorithm_NO_COST_SCALING = 0,
  GlopParameters_CostScalingAlgorithm_CONTAIN_ONE_COST_SCALING = 1,
  GlopParameters_CostScalingAlgorithm_MEAN_COST_SCALING = 2,
  GlopParameters_CostScalingAlgorithm_MEDIAN_COST_SCALING = 3,
};
 
OR_PROTO_DLL extern const uint32_t GlopParameters_CostScalingAlgorithm_internal_data_[];
inline constexpr GlopParameters_CostScalingAlgorithm GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MIN =
    static_cast<GlopParameters_CostScalingAlgorithm>(0);
inline constexpr GlopParameters_CostScalingAlgorithm GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MAX =
    static_cast<GlopParameters_CostScalingAlgorithm>(3);
inline bool GlopParameters_CostScalingAlgorithm_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_ARRAYSIZE = 3 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL GlopParameters_CostScalingAlgorithm_descriptor();
template <typename T>
const ::std::string& GlopParameters_CostScalingAlgorithm_Name(T value) {
  static_assert(::std::is_same<T, GlopParameters_CostScalingAlgorithm>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to CostScalingAlgorithm_Name().");
  return GlopParameters_CostScalingAlgorithm_Name(static_cast<GlopParameters_CostScalingAlgorithm>(value));
}
template <>
inline const ::std::string& GlopParameters_CostScalingAlgorithm_Name(GlopParameters_CostScalingAlgorithm value) {
  return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_CostScalingAlgorithm_descriptor, 0, 3>(
      static_cast<int>(value));
}
inline bool GlopParameters_CostScalingAlgorithm_Parse(
    ::absl::string_view name, GlopParameters_CostScalingAlgorithm* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<GlopParameters_CostScalingAlgorithm>(GlopParameters_CostScalingAlgorithm_descriptor(), name,
                                           value);
}
 
// ===================================================================
 
 
// -------------------------------------------------------------------
 
class OR_PROTO_DLL GlopParameters final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.glop.GlopParameters) */ {
 public:
  inline GlopParameters() : GlopParameters(nullptr) {}
  ~GlopParameters() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(GlopParameters* PROTOBUF_NONNULL msg, std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(GlopParameters));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GlopParameters(::google::protobuf::internal::ConstantInitialized);
 
  inline GlopParameters(const GlopParameters& from) : GlopParameters(nullptr, from) {}
  inline GlopParameters(GlopParameters&& from) noexcept
      : GlopParameters(nullptr, ::std::move(from)) {}
  inline GlopParameters& operator=(const GlopParameters& from) {
    CopyFrom(from);
    return *this;
  }
  inline GlopParameters& operator=(GlopParameters&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }
 
  static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const GlopParameters& default_instance() {
    return *reinterpret_cast<const GlopParameters*>(
        &_GlopParameters_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(GlopParameters& a, GlopParameters& b) { a.Swap(&b); }
  inline void Swap(GlopParameters* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GlopParameters* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  GlopParameters* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<GlopParameters>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const GlopParameters& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const GlopParameters& from) { GlopParameters::MergeImpl(*this, from); }
 
  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);
 
  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
 
  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(GlopParameters* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "operations_research.glop.GlopParameters"; }
 
 protected:
  explicit GlopParameters(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  GlopParameters(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GlopParameters& from);
  GlopParameters(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, GlopParameters&& from) noexcept
      : GlopParameters(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();
 
 public:
  static constexpr auto InternalGenerateClassData_();
 
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using ScalingAlgorithm = GlopParameters_ScalingAlgorithm;
  static constexpr ScalingAlgorithm DEFAULT = GlopParameters_ScalingAlgorithm_DEFAULT;
  static constexpr ScalingAlgorithm EQUILIBRATION = GlopParameters_ScalingAlgorithm_EQUILIBRATION;
  static constexpr ScalingAlgorithm LINEAR_PROGRAM = GlopParameters_ScalingAlgorithm_LINEAR_PROGRAM;
  static inline bool ScalingAlgorithm_IsValid(int value) {
    return GlopParameters_ScalingAlgorithm_IsValid(value);
  }
  static constexpr ScalingAlgorithm ScalingAlgorithm_MIN = GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MIN;
  static constexpr ScalingAlgorithm ScalingAlgorithm_MAX = GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MAX;
  static constexpr int ScalingAlgorithm_ARRAYSIZE = GlopParameters_ScalingAlgorithm_ScalingAlgorithm_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ScalingAlgorithm_descriptor() {
    return GlopParameters_ScalingAlgorithm_descriptor();
  }
  template <typename T>
  static inline const ::std::string& ScalingAlgorithm_Name(T value) {
    return GlopParameters_ScalingAlgorithm_Name(value);
  }
  static inline bool ScalingAlgorithm_Parse(
      ::absl::string_view name, ScalingAlgorithm* PROTOBUF_NONNULL value) {
    return GlopParameters_ScalingAlgorithm_Parse(name, value);
  }
  using SolverBehavior = GlopParameters_SolverBehavior;
  static constexpr SolverBehavior ALWAYS_DO = GlopParameters_SolverBehavior_ALWAYS_DO;
  static constexpr SolverBehavior NEVER_DO = GlopParameters_SolverBehavior_NEVER_DO;
  static constexpr SolverBehavior LET_SOLVER_DECIDE = GlopParameters_SolverBehavior_LET_SOLVER_DECIDE;
  static inline bool SolverBehavior_IsValid(int value) {
    return GlopParameters_SolverBehavior_IsValid(value);
  }
  static constexpr SolverBehavior SolverBehavior_MIN = GlopParameters_SolverBehavior_SolverBehavior_MIN;
  static constexpr SolverBehavior SolverBehavior_MAX = GlopParameters_SolverBehavior_SolverBehavior_MAX;
  static constexpr int SolverBehavior_ARRAYSIZE = GlopParameters_SolverBehavior_SolverBehavior_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SolverBehavior_descriptor() {
    return GlopParameters_SolverBehavior_descriptor();
  }
  template <typename T>
  static inline const ::std::string& SolverBehavior_Name(T value) {
    return GlopParameters_SolverBehavior_Name(value);
  }
  static inline bool SolverBehavior_Parse(
      ::absl::string_view name, SolverBehavior* PROTOBUF_NONNULL value) {
    return GlopParameters_SolverBehavior_Parse(name, value);
  }
  using PricingRule = GlopParameters_PricingRule;
  static constexpr PricingRule DANTZIG = GlopParameters_PricingRule_DANTZIG;
  static constexpr PricingRule STEEPEST_EDGE = GlopParameters_PricingRule_STEEPEST_EDGE;
  static constexpr PricingRule DEVEX = GlopParameters_PricingRule_DEVEX;
  static inline bool PricingRule_IsValid(int value) {
    return GlopParameters_PricingRule_IsValid(value);
  }
  static constexpr PricingRule PricingRule_MIN = GlopParameters_PricingRule_PricingRule_MIN;
  static constexpr PricingRule PricingRule_MAX = GlopParameters_PricingRule_PricingRule_MAX;
  static constexpr int PricingRule_ARRAYSIZE = GlopParameters_PricingRule_PricingRule_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL PricingRule_descriptor() {
    return GlopParameters_PricingRule_descriptor();
  }
  template <typename T>
  static inline const ::std::string& PricingRule_Name(T value) {
    return GlopParameters_PricingRule_Name(value);
  }
  static inline bool PricingRule_Parse(
      ::absl::string_view name, PricingRule* PROTOBUF_NONNULL value) {
    return GlopParameters_PricingRule_Parse(name, value);
  }
  using InitialBasisHeuristic = GlopParameters_InitialBasisHeuristic;
  static constexpr InitialBasisHeuristic NONE = GlopParameters_InitialBasisHeuristic_NONE;
  static constexpr InitialBasisHeuristic BIXBY = GlopParameters_InitialBasisHeuristic_BIXBY;
  static constexpr InitialBasisHeuristic TRIANGULAR = GlopParameters_InitialBasisHeuristic_TRIANGULAR;
  static constexpr InitialBasisHeuristic MAROS = GlopParameters_InitialBasisHeuristic_MAROS;
  static inline bool InitialBasisHeuristic_IsValid(int value) {
    return GlopParameters_InitialBasisHeuristic_IsValid(value);
  }
  static constexpr InitialBasisHeuristic InitialBasisHeuristic_MIN = GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MIN;
  static constexpr InitialBasisHeuristic InitialBasisHeuristic_MAX = GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MAX;
  static constexpr int InitialBasisHeuristic_ARRAYSIZE = GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL InitialBasisHeuristic_descriptor() {
    return GlopParameters_InitialBasisHeuristic_descriptor();
  }
  template <typename T>
  static inline const ::std::string& InitialBasisHeuristic_Name(T value) {
    return GlopParameters_InitialBasisHeuristic_Name(value);
  }
  static inline bool InitialBasisHeuristic_Parse(
      ::absl::string_view name, InitialBasisHeuristic* PROTOBUF_NONNULL value) {
    return GlopParameters_InitialBasisHeuristic_Parse(name, value);
  }
  using CostScalingAlgorithm = GlopParameters_CostScalingAlgorithm;
  static constexpr CostScalingAlgorithm NO_COST_SCALING = GlopParameters_CostScalingAlgorithm_NO_COST_SCALING;
  static constexpr CostScalingAlgorithm CONTAIN_ONE_COST_SCALING = GlopParameters_CostScalingAlgorithm_CONTAIN_ONE_COST_SCALING;
  static constexpr CostScalingAlgorithm MEAN_COST_SCALING = GlopParameters_CostScalingAlgorithm_MEAN_COST_SCALING;
  static constexpr CostScalingAlgorithm MEDIAN_COST_SCALING = GlopParameters_CostScalingAlgorithm_MEDIAN_COST_SCALING;
  static inline bool CostScalingAlgorithm_IsValid(int value) {
    return GlopParameters_CostScalingAlgorithm_IsValid(value);
  }
  static constexpr CostScalingAlgorithm CostScalingAlgorithm_MIN = GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MIN;
  static constexpr CostScalingAlgorithm CostScalingAlgorithm_MAX = GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MAX;
  static constexpr int CostScalingAlgorithm_ARRAYSIZE = GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL CostScalingAlgorithm_descriptor() {
    return GlopParameters_CostScalingAlgorithm_descriptor();
  }
  template <typename T>
  static inline const ::std::string& CostScalingAlgorithm_Name(T value) {
    return GlopParameters_CostScalingAlgorithm_Name(value);
  }
  static inline bool CostScalingAlgorithm_Parse(
      ::absl::string_view name, CostScalingAlgorithm* PROTOBUF_NONNULL value) {
    return GlopParameters_CostScalingAlgorithm_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
  enum : int {
    kUseDualSimplexFieldNumber = 31,
    kAllowSimplexAlgorithmChangeFieldNumber = 32,
    kPerturbCostsInDualSimplexFieldNumber = 53,
    kLogSearchProgressFieldNumber = 61,
    kDualPricePrioritizeNormFieldNumber = 69,
    kUseAbslRandomFieldNumber = 72,
    kFeasibilityRuleFieldNumber = 1,
    kOptimizationRuleFieldNumber = 2,
    kRefactorizationThresholdFieldNumber = 6,
    kRecomputeReducedCostsThresholdFieldNumber = 8,
    kRecomputeEdgesNormThresholdFieldNumber = 9,
    kPrimalFeasibilityToleranceFieldNumber = 10,
    kDualFeasibilityToleranceFieldNumber = 11,
    kRatioTestZeroThresholdFieldNumber = 12,
    kHarrisToleranceRatioFieldNumber = 13,
    kSmallPivotThresholdFieldNumber = 14,
    kMinimumAcceptablePivotFieldNumber = 15,
    kInitialBasisFieldNumber = 17,
    kBasisRefactorizationPeriodFieldNumber = 19,
    kDualizerThresholdFieldNumber = 21,
    kSolutionFeasibilityToleranceFieldNumber = 22,
    kSolveDualProblemFieldNumber = 20,
    kUseScalingFieldNumber = 16,
    kUseTransposedMatrixFieldNumber = 18,
    kProvideStrongOptimalGuaranteeFieldNumber = 24,
    kUsePreprocessingFieldNumber = 34,
    kLuFactorizationPivotThresholdFieldNumber = 25,
    kMaxTimeInSecondsFieldNumber = 26,
    kMaxNumberOfIterationsFieldNumber = 27,
    kMarkowitzSingularityThresholdFieldNumber = 30,
    kMarkowitzZlatevParameterFieldNumber = 29,
    kDevexWeightsResetPeriodFieldNumber = 33,
    kDualSmallPivotThresholdFieldNumber = 38,
    kPreprocessorZeroToleranceFieldNumber = 39,
    kObjectiveLowerLimitFieldNumber = 40,
    kObjectiveUpperLimitFieldNumber = 41,
    kUseMiddleProductFormUpdateFieldNumber = 35,
    kInitializeDevexWithColumnNormsFieldNumber = 36,
    kExploitSingletonColumnInInitialBasisFieldNumber = 37,
    kChangeStatusToImpreciseFieldNumber = 58,
    kRandomSeedFieldNumber = 43,
    kDegenerateMinistepFactorFieldNumber = 42,
    kMaxDeterministicTimeFieldNumber = 45,
    kNumOmpThreadsFieldNumber = 44,
    kScalingMethodFieldNumber = 57,
    kDropToleranceFieldNumber = 52,
    kRelativeCostPerturbationFieldNumber = 54,
    kRelativeMaxCostPerturbationFieldNumber = 55,
    kMaxNumberOfReoptimizationsFieldNumber = 56,
    kInitialConditionNumberThresholdFieldNumber = 59,
    kCostScalingFieldNumber = 60,
    kUseDedicatedDualFeasibilityAlgorithmFieldNumber = 62,
    kDynamicallyAdjustRefactorizationPeriodFieldNumber = 63,
    kPushToVertexFieldNumber = 65,
    kLogToStdoutFieldNumber = 66,
    kCrossoverBoundSnappingDistanceFieldNumber = 64,
    kMaxValidMagnitudeFieldNumber = 70,
    kDropMagnitudeFieldNumber = 71,
    kUseImpliedFreePreprocessorFieldNumber = 67,
  };
  // optional bool use_dual_simplex = 31 [default = false];
  bool has_use_dual_simplex() const;
  void clear_use_dual_simplex() ;
  bool use_dual_simplex() const;
  void set_use_dual_simplex(bool value);
 
  private:
  bool _internal_use_dual_simplex() const;
  void _internal_set_use_dual_simplex(bool value);
 
  public:
  // optional bool allow_simplex_algorithm_change = 32 [default = false];
  bool has_allow_simplex_algorithm_change() const;
  void clear_allow_simplex_algorithm_change() ;
  bool allow_simplex_algorithm_change() const;
  void set_allow_simplex_algorithm_change(bool value);
 
  private:
  bool _internal_allow_simplex_algorithm_change() const;
  void _internal_set_allow_simplex_algorithm_change(bool value);
 
  public:
  // optional bool perturb_costs_in_dual_simplex = 53 [default = false];
  bool has_perturb_costs_in_dual_simplex() const;
  void clear_perturb_costs_in_dual_simplex() ;
  bool perturb_costs_in_dual_simplex() const;
  void set_perturb_costs_in_dual_simplex(bool value);
 
  private:
  bool _internal_perturb_costs_in_dual_simplex() const;
  void _internal_set_perturb_costs_in_dual_simplex(bool value);
 
  public:
  // optional bool log_search_progress = 61 [default = false];
  bool has_log_search_progress() const;
  void clear_log_search_progress() ;
  bool log_search_progress() const;
  void set_log_search_progress(bool value);
 
  private:
  bool _internal_log_search_progress() const;
  void _internal_set_log_search_progress(bool value);
 
  public:
  // optional bool dual_price_prioritize_norm = 69 [default = false];
  bool has_dual_price_prioritize_norm() const;
  void clear_dual_price_prioritize_norm() ;
  bool dual_price_prioritize_norm() const;
  void set_dual_price_prioritize_norm(bool value);
 
  private:
  bool _internal_dual_price_prioritize_norm() const;
  void _internal_set_dual_price_prioritize_norm(bool value);
 
  public:
  // optional bool use_absl_random = 72 [default = false];
  bool has_use_absl_random() const;
  void clear_use_absl_random() ;
  bool use_absl_random() const;
  void set_use_absl_random(bool value);
 
  private:
  bool _internal_use_absl_random() const;
  void _internal_set_use_absl_random(bool value);
 
  public:
  // optional .operations_research.glop.GlopParameters.PricingRule feasibility_rule = 1 [default = STEEPEST_EDGE];
  bool has_feasibility_rule() const;
  void clear_feasibility_rule() ;
  ::operations_research::glop::GlopParameters_PricingRule feasibility_rule() const;
  void set_feasibility_rule(::operations_research::glop::GlopParameters_PricingRule value);
 
  private:
  ::operations_research::glop::GlopParameters_PricingRule _internal_feasibility_rule() const;
  void _internal_set_feasibility_rule(::operations_research::glop::GlopParameters_PricingRule value);
 
  public:
  // optional .operations_research.glop.GlopParameters.PricingRule optimization_rule = 2 [default = STEEPEST_EDGE];
  bool has_optimization_rule() const;
  void clear_optimization_rule() ;
  ::operations_research::glop::GlopParameters_PricingRule optimization_rule() const;
  void set_optimization_rule(::operations_research::glop::GlopParameters_PricingRule value);
 
  private:
  ::operations_research::glop::GlopParameters_PricingRule _internal_optimization_rule() const;
  void _internal_set_optimization_rule(::operations_research::glop::GlopParameters_PricingRule value);
 
  public:
  // optional double refactorization_threshold = 6 [default = 1e-09];
  bool has_refactorization_threshold() const;
  void clear_refactorization_threshold() ;
  double refactorization_threshold() const;
  void set_refactorization_threshold(double value);
 
  private:
  double _internal_refactorization_threshold() const;
  void _internal_set_refactorization_threshold(double value);
 
  public:
  // optional double recompute_reduced_costs_threshold = 8 [default = 1e-08];
  bool has_recompute_reduced_costs_threshold() const;
  void clear_recompute_reduced_costs_threshold() ;
  double recompute_reduced_costs_threshold() const;
  void set_recompute_reduced_costs_threshold(double value);
 
  private:
  double _internal_recompute_reduced_costs_threshold() const;
  void _internal_set_recompute_reduced_costs_threshold(double value);
 
  public:
  // optional double recompute_edges_norm_threshold = 9 [default = 100];
  bool has_recompute_edges_norm_threshold() const;
  void clear_recompute_edges_norm_threshold() ;
  double recompute_edges_norm_threshold() const;
  void set_recompute_edges_norm_threshold(double value);
 
  private:
  double _internal_recompute_edges_norm_threshold() const;
  void _internal_set_recompute_edges_norm_threshold(double value);
 
  public:
  // optional double primal_feasibility_tolerance = 10 [default = 1e-08];
  bool has_primal_feasibility_tolerance() const;
  void clear_primal_feasibility_tolerance() ;
  double primal_feasibility_tolerance() const;
  void set_primal_feasibility_tolerance(double value);
 
  private:
  double _internal_primal_feasibility_tolerance() const;
  void _internal_set_primal_feasibility_tolerance(double value);
 
  public:
  // optional double dual_feasibility_tolerance = 11 [default = 1e-08];
  bool has_dual_feasibility_tolerance() const;
  void clear_dual_feasibility_tolerance() ;
  double dual_feasibility_tolerance() const;
  void set_dual_feasibility_tolerance(double value);
 
  private:
  double _internal_dual_feasibility_tolerance() const;
  void _internal_set_dual_feasibility_tolerance(double value);
 
  public:
  // optional double ratio_test_zero_threshold = 12 [default = 1e-09];
  bool has_ratio_test_zero_threshold() const;
  void clear_ratio_test_zero_threshold() ;
  double ratio_test_zero_threshold() const;
  void set_ratio_test_zero_threshold(double value);
 
  private:
  double _internal_ratio_test_zero_threshold() const;
  void _internal_set_ratio_test_zero_threshold(double value);
 
  public:
  // optional double harris_tolerance_ratio = 13 [default = 0.5];
  bool has_harris_tolerance_ratio() const;
  void clear_harris_tolerance_ratio() ;
  double harris_tolerance_ratio() const;
  void set_harris_tolerance_ratio(double value);
 
  private:
  double _internal_harris_tolerance_ratio() const;
  void _internal_set_harris_tolerance_ratio(double value);
 
  public:
  // optional double small_pivot_threshold = 14 [default = 1e-06];
  bool has_small_pivot_threshold() const;
  void clear_small_pivot_threshold() ;
  double small_pivot_threshold() const;
  void set_small_pivot_threshold(double value);
 
  private:
  double _internal_small_pivot_threshold() const;
  void _internal_set_small_pivot_threshold(double value);
 
  public:
  // optional double minimum_acceptable_pivot = 15 [default = 1e-06];
  bool has_minimum_acceptable_pivot() const;
  void clear_minimum_acceptable_pivot() ;
  double minimum_acceptable_pivot() const;
  void set_minimum_acceptable_pivot(double value);
 
  private:
  double _internal_minimum_acceptable_pivot() const;
  void _internal_set_minimum_acceptable_pivot(double value);
 
  public:
  // optional .operations_research.glop.GlopParameters.InitialBasisHeuristic initial_basis = 17 [default = TRIANGULAR];
  bool has_initial_basis() const;
  void clear_initial_basis() ;
  ::operations_research::glop::GlopParameters_InitialBasisHeuristic initial_basis() const;
  void set_initial_basis(::operations_research::glop::GlopParameters_InitialBasisHeuristic value);
 
  private:
  ::operations_research::glop::GlopParameters_InitialBasisHeuristic _internal_initial_basis() const;
  void _internal_set_initial_basis(::operations_research::glop::GlopParameters_InitialBasisHeuristic value);
 
  public:
  // optional int32 basis_refactorization_period = 19 [default = 64];
  bool has_basis_refactorization_period() const;
  void clear_basis_refactorization_period() ;
  ::int32_t basis_refactorization_period() const;
  void set_basis_refactorization_period(::int32_t value);
 
  private:
  ::int32_t _internal_basis_refactorization_period() const;
  void _internal_set_basis_refactorization_period(::int32_t value);
 
  public:
  // optional double dualizer_threshold = 21 [default = 1.5];
  bool has_dualizer_threshold() const;
  void clear_dualizer_threshold() ;
  double dualizer_threshold() const;
  void set_dualizer_threshold(double value);
 
  private:
  double _internal_dualizer_threshold() const;
  void _internal_set_dualizer_threshold(double value);
 
  public:
  // optional double solution_feasibility_tolerance = 22 [default = 1e-06];
  bool has_solution_feasibility_tolerance() const;
  void clear_solution_feasibility_tolerance() ;
  double solution_feasibility_tolerance() const;
  void set_solution_feasibility_tolerance(double value);
 
  private:
  double _internal_solution_feasibility_tolerance() const;
  void _internal_set_solution_feasibility_tolerance(double value);
 
  public:
  // optional .operations_research.glop.GlopParameters.SolverBehavior solve_dual_problem = 20 [default = LET_SOLVER_DECIDE];
  bool has_solve_dual_problem() const;
  void clear_solve_dual_problem() ;
  ::operations_research::glop::GlopParameters_SolverBehavior solve_dual_problem() const;
  void set_solve_dual_problem(::operations_research::glop::GlopParameters_SolverBehavior value);
 
  private:
  ::operations_research::glop::GlopParameters_SolverBehavior _internal_solve_dual_problem() const;
  void _internal_set_solve_dual_problem(::operations_research::glop::GlopParameters_SolverBehavior value);
 
  public:
  // optional bool use_scaling = 16 [default = true];
  bool has_use_scaling() const;
  void clear_use_scaling() ;
  bool use_scaling() const;
  void set_use_scaling(bool value);
 
  private:
  bool _internal_use_scaling() const;
  void _internal_set_use_scaling(bool value);
 
  public:
  // optional bool use_transposed_matrix = 18 [default = true];
  bool has_use_transposed_matrix() const;
  void clear_use_transposed_matrix() ;
  bool use_transposed_matrix() const;
  void set_use_transposed_matrix(bool value);
 
  private:
  bool _internal_use_transposed_matrix() const;
  void _internal_set_use_transposed_matrix(bool value);
 
  public:
  // optional bool provide_strong_optimal_guarantee = 24 [default = true];
  bool has_provide_strong_optimal_guarantee() const;
  void clear_provide_strong_optimal_guarantee() ;
  bool provide_strong_optimal_guarantee() const;
  void set_provide_strong_optimal_guarantee(bool value);
 
  private:
  bool _internal_provide_strong_optimal_guarantee() const;
  void _internal_set_provide_strong_optimal_guarantee(bool value);
 
  public:
  // optional bool use_preprocessing = 34 [default = true];
  bool has_use_preprocessing() const;
  void clear_use_preprocessing() ;
  bool use_preprocessing() const;
  void set_use_preprocessing(bool value);
 
  private:
  bool _internal_use_preprocessing() const;
  void _internal_set_use_preprocessing(bool value);
 
  public:
  // optional double lu_factorization_pivot_threshold = 25 [default = 0.01];
  bool has_lu_factorization_pivot_threshold() const;
  void clear_lu_factorization_pivot_threshold() ;
  double lu_factorization_pivot_threshold() const;
  void set_lu_factorization_pivot_threshold(double value);
 
  private:
  double _internal_lu_factorization_pivot_threshold() const;
  void _internal_set_lu_factorization_pivot_threshold(double value);
 
  public:
  // optional double max_time_in_seconds = 26 [default = inf];
  bool has_max_time_in_seconds() const;
  void clear_max_time_in_seconds() ;
  double max_time_in_seconds() const;
  void set_max_time_in_seconds(double value);
 
  private:
  double _internal_max_time_in_seconds() const;
  void _internal_set_max_time_in_seconds(double value);
 
  public:
  // optional int64 max_number_of_iterations = 27 [default = -1];
  bool has_max_number_of_iterations() const;
  void clear_max_number_of_iterations() ;
  ::int64_t max_number_of_iterations() const;
  void set_max_number_of_iterations(::int64_t value);
 
  private:
  ::int64_t _internal_max_number_of_iterations() const;
  void _internal_set_max_number_of_iterations(::int64_t value);
 
  public:
  // optional double markowitz_singularity_threshold = 30 [default = 1e-15];
  bool has_markowitz_singularity_threshold() const;
  void clear_markowitz_singularity_threshold() ;
  double markowitz_singularity_threshold() const;
  void set_markowitz_singularity_threshold(double value);
 
  private:
  double _internal_markowitz_singularity_threshold() const;
  void _internal_set_markowitz_singularity_threshold(double value);
 
  public:
  // optional int32 markowitz_zlatev_parameter = 29 [default = 3];
  bool has_markowitz_zlatev_parameter() const;
  void clear_markowitz_zlatev_parameter() ;
  ::int32_t markowitz_zlatev_parameter() const;
  void set_markowitz_zlatev_parameter(::int32_t value);
 
  private:
  ::int32_t _internal_markowitz_zlatev_parameter() const;
  void _internal_set_markowitz_zlatev_parameter(::int32_t value);
 
  public:
  // optional int32 devex_weights_reset_period = 33 [default = 150];
  bool has_devex_weights_reset_period() const;
  void clear_devex_weights_reset_period() ;
  ::int32_t devex_weights_reset_period() const;
  void set_devex_weights_reset_period(::int32_t value);
 
  private:
  ::int32_t _internal_devex_weights_reset_period() const;
  void _internal_set_devex_weights_reset_period(::int32_t value);
 
  public:
  // optional double dual_small_pivot_threshold = 38 [default = 0.0001];
  bool has_dual_small_pivot_threshold() const;
  void clear_dual_small_pivot_threshold() ;
  double dual_small_pivot_threshold() const;
  void set_dual_small_pivot_threshold(double value);
 
  private:
  double _internal_dual_small_pivot_threshold() const;
  void _internal_set_dual_small_pivot_threshold(double value);
 
  public:
  // optional double preprocessor_zero_tolerance = 39 [default = 1e-09];
  bool has_preprocessor_zero_tolerance() const;
  void clear_preprocessor_zero_tolerance() ;
  double preprocessor_zero_tolerance() const;
  void set_preprocessor_zero_tolerance(double value);
 
  private:
  double _internal_preprocessor_zero_tolerance() const;
  void _internal_set_preprocessor_zero_tolerance(double value);
 
  public:
  // optional double objective_lower_limit = 40 [default = -inf];
  bool has_objective_lower_limit() const;
  void clear_objective_lower_limit() ;
  double objective_lower_limit() const;
  void set_objective_lower_limit(double value);
 
  private:
  double _internal_objective_lower_limit() const;
  void _internal_set_objective_lower_limit(double value);
 
  public:
  // optional double objective_upper_limit = 41 [default = inf];
  bool has_objective_upper_limit() const;
  void clear_objective_upper_limit() ;
  double objective_upper_limit() const;
  void set_objective_upper_limit(double value);
 
  private:
  double _internal_objective_upper_limit() const;
  void _internal_set_objective_upper_limit(double value);
 
  public:
  // optional bool use_middle_product_form_update = 35 [default = true];
  bool has_use_middle_product_form_update() const;
  void clear_use_middle_product_form_update() ;
  bool use_middle_product_form_update() const;
  void set_use_middle_product_form_update(bool value);
 
  private:
  bool _internal_use_middle_product_form_update() const;
  void _internal_set_use_middle_product_form_update(bool value);
 
  public:
  // optional bool initialize_devex_with_column_norms = 36 [default = true];
  bool has_initialize_devex_with_column_norms() const;
  void clear_initialize_devex_with_column_norms() ;
  bool initialize_devex_with_column_norms() const;
  void set_initialize_devex_with_column_norms(bool value);
 
  private:
  bool _internal_initialize_devex_with_column_norms() const;
  void _internal_set_initialize_devex_with_column_norms(bool value);
 
  public:
  // optional bool exploit_singleton_column_in_initial_basis = 37 [default = true];
  bool has_exploit_singleton_column_in_initial_basis() const;
  void clear_exploit_singleton_column_in_initial_basis() ;
  bool exploit_singleton_column_in_initial_basis() const;
  void set_exploit_singleton_column_in_initial_basis(bool value);
 
  private:
  bool _internal_exploit_singleton_column_in_initial_basis() const;
  void _internal_set_exploit_singleton_column_in_initial_basis(bool value);
 
  public:
  // optional bool change_status_to_imprecise = 58 [default = true];
  bool has_change_status_to_imprecise() const;
  void clear_change_status_to_imprecise() ;
  bool change_status_to_imprecise() const;
  void set_change_status_to_imprecise(bool value);
 
  private:
  bool _internal_change_status_to_imprecise() const;
  void _internal_set_change_status_to_imprecise(bool value);
 
  public:
  // optional int32 random_seed = 43 [default = 1];
  bool has_random_seed() const;
  void clear_random_seed() ;
  ::int32_t random_seed() const;
  void set_random_seed(::int32_t value);
 
  private:
  ::int32_t _internal_random_seed() const;
  void _internal_set_random_seed(::int32_t value);
 
  public:
  // optional double degenerate_ministep_factor = 42 [default = 0.01];
  bool has_degenerate_ministep_factor() const;
  void clear_degenerate_ministep_factor() ;
  double degenerate_ministep_factor() const;
  void set_degenerate_ministep_factor(double value);
 
  private:
  double _internal_degenerate_ministep_factor() const;
  void _internal_set_degenerate_ministep_factor(double value);
 
  public:
  // optional double max_deterministic_time = 45 [default = inf];
  bool has_max_deterministic_time() const;
  void clear_max_deterministic_time() ;
  double max_deterministic_time() const;
  void set_max_deterministic_time(double value);
 
  private:
  double _internal_max_deterministic_time() const;
  void _internal_set_max_deterministic_time(double value);
 
  public:
  // optional int32 num_omp_threads = 44 [default = 1];
  bool has_num_omp_threads() const;
  void clear_num_omp_threads() ;
  ::int32_t num_omp_threads() const;
  void set_num_omp_threads(::int32_t value);
 
  private:
  ::int32_t _internal_num_omp_threads() const;
  void _internal_set_num_omp_threads(::int32_t value);
 
  public:
  // optional .operations_research.glop.GlopParameters.ScalingAlgorithm scaling_method = 57 [default = EQUILIBRATION];
  bool has_scaling_method() const;
  void clear_scaling_method() ;
  ::operations_research::glop::GlopParameters_ScalingAlgorithm scaling_method() const;
  void set_scaling_method(::operations_research::glop::GlopParameters_ScalingAlgorithm value);
 
  private:
  ::operations_research::glop::GlopParameters_ScalingAlgorithm _internal_scaling_method() const;
  void _internal_set_scaling_method(::operations_research::glop::GlopParameters_ScalingAlgorithm value);
 
  public:
  // optional double drop_tolerance = 52 [default = 1e-14];
  bool has_drop_tolerance() const;
  void clear_drop_tolerance() ;
  double drop_tolerance() const;
  void set_drop_tolerance(double value);
 
  private:
  double _internal_drop_tolerance() const;
  void _internal_set_drop_tolerance(double value);
 
  public:
  // optional double relative_cost_perturbation = 54 [default = 1e-05];
  bool has_relative_cost_perturbation() const;
  void clear_relative_cost_perturbation() ;
  double relative_cost_perturbation() const;
  void set_relative_cost_perturbation(double value);
 
  private:
  double _internal_relative_cost_perturbation() const;
  void _internal_set_relative_cost_perturbation(double value);
 
  public:
  // optional double relative_max_cost_perturbation = 55 [default = 1e-07];
  bool has_relative_max_cost_perturbation() const;
  void clear_relative_max_cost_perturbation() ;
  double relative_max_cost_perturbation() const;
  void set_relative_max_cost_perturbation(double value);
 
  private:
  double _internal_relative_max_cost_perturbation() const;
  void _internal_set_relative_max_cost_perturbation(double value);
 
  public:
  // optional double max_number_of_reoptimizations = 56 [default = 40];
  bool has_max_number_of_reoptimizations() const;
  void clear_max_number_of_reoptimizations() ;
  double max_number_of_reoptimizations() const;
  void set_max_number_of_reoptimizations(double value);
 
  private:
  double _internal_max_number_of_reoptimizations() const;
  void _internal_set_max_number_of_reoptimizations(double value);
 
  public:
  // optional double initial_condition_number_threshold = 59 [default = 1e+50];
  bool has_initial_condition_number_threshold() const;
  void clear_initial_condition_number_threshold() ;
  double initial_condition_number_threshold() const;
  void set_initial_condition_number_threshold(double value);
 
  private:
  double _internal_initial_condition_number_threshold() const;
  void _internal_set_initial_condition_number_threshold(double value);
 
  public:
  // optional .operations_research.glop.GlopParameters.CostScalingAlgorithm cost_scaling = 60 [default = CONTAIN_ONE_COST_SCALING];
  bool has_cost_scaling() const;
  void clear_cost_scaling() ;
  ::operations_research::glop::GlopParameters_CostScalingAlgorithm cost_scaling() const;
  void set_cost_scaling(::operations_research::glop::GlopParameters_CostScalingAlgorithm value);
 
  private:
  ::operations_research::glop::GlopParameters_CostScalingAlgorithm _internal_cost_scaling() const;
  void _internal_set_cost_scaling(::operations_research::glop::GlopParameters_CostScalingAlgorithm value);
 
  public:
  // optional bool use_dedicated_dual_feasibility_algorithm = 62 [default = true];
  bool has_use_dedicated_dual_feasibility_algorithm() const;
  void clear_use_dedicated_dual_feasibility_algorithm() ;
  bool use_dedicated_dual_feasibility_algorithm() const;
  void set_use_dedicated_dual_feasibility_algorithm(bool value);
 
  private:
  bool _internal_use_dedicated_dual_feasibility_algorithm() const;
  void _internal_set_use_dedicated_dual_feasibility_algorithm(bool value);
 
  public:
  // optional bool dynamically_adjust_refactorization_period = 63 [default = true];
  bool has_dynamically_adjust_refactorization_period() const;
  void clear_dynamically_adjust_refactorization_period() ;
  bool dynamically_adjust_refactorization_period() const;
  void set_dynamically_adjust_refactorization_period(bool value);
 
  private:
  bool _internal_dynamically_adjust_refactorization_period() const;
  void _internal_set_dynamically_adjust_refactorization_period(bool value);
 
  public:
  // optional bool push_to_vertex = 65 [default = true];
  bool has_push_to_vertex() const;
  void clear_push_to_vertex() ;
  bool push_to_vertex() const;
  void set_push_to_vertex(bool value);
 
  private:
  bool _internal_push_to_vertex() const;
  void _internal_set_push_to_vertex(bool value);
 
  public:
  // optional bool log_to_stdout = 66 [default = true];
  bool has_log_to_stdout() const;
  void clear_log_to_stdout() ;
  bool log_to_stdout() const;
  void set_log_to_stdout(bool value);
 
  private:
  bool _internal_log_to_stdout() const;
  void _internal_set_log_to_stdout(bool value);
 
  public:
  // optional double crossover_bound_snapping_distance = 64 [default = inf];
  bool has_crossover_bound_snapping_distance() const;
  void clear_crossover_bound_snapping_distance() ;
  double crossover_bound_snapping_distance() const;
  void set_crossover_bound_snapping_distance(double value);
 
  private:
  double _internal_crossover_bound_snapping_distance() const;
  void _internal_set_crossover_bound_snapping_distance(double value);
 
  public:
  // optional double max_valid_magnitude = 70 [default = 1e+30];
  bool has_max_valid_magnitude() const;
  void clear_max_valid_magnitude() ;
  double max_valid_magnitude() const;
  void set_max_valid_magnitude(double value);
 
  private:
  double _internal_max_valid_magnitude() const;
  void _internal_set_max_valid_magnitude(double value);
 
  public:
  // optional double drop_magnitude = 71 [default = 1e-30];
  bool has_drop_magnitude() const;
  void clear_drop_magnitude() ;
  double drop_magnitude() const;
  void set_drop_magnitude(double value);
 
  private:
  double _internal_drop_magnitude() const;
  void _internal_set_drop_magnitude(double value);
 
  public:
  // optional bool use_implied_free_preprocessor = 67 [default = true];
  bool has_use_implied_free_preprocessor() const;
  void clear_use_implied_free_preprocessor() ;
  bool use_implied_free_preprocessor() const;
  void set_use_implied_free_preprocessor(bool value);
 
  private:
  bool _internal_use_implied_free_preprocessor() const;
  void _internal_set_use_implied_free_preprocessor(bool value);
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.glop.GlopParameters)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<5, 59,
                                   6, 0,
                                   11>
      _table_;
 
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const GlopParameters& from_msg);
    ::google::protobuf::internal::HasBits<2> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    bool use_dual_simplex_;
    bool allow_simplex_algorithm_change_;
    bool perturb_costs_in_dual_simplex_;
    bool log_search_progress_;
    bool dual_price_prioritize_norm_;
    bool use_absl_random_;
    int feasibility_rule_;
    int optimization_rule_;
    double refactorization_threshold_;
    double recompute_reduced_costs_threshold_;
    double recompute_edges_norm_threshold_;
    double primal_feasibility_tolerance_;
    double dual_feasibility_tolerance_;
    double ratio_test_zero_threshold_;
    double harris_tolerance_ratio_;
    double small_pivot_threshold_;
    double minimum_acceptable_pivot_;
    int initial_basis_;
    ::int32_t basis_refactorization_period_;
    double dualizer_threshold_;
    double solution_feasibility_tolerance_;
    int solve_dual_problem_;
    bool use_scaling_;
    bool use_transposed_matrix_;
    bool provide_strong_optimal_guarantee_;
    bool use_preprocessing_;
    double lu_factorization_pivot_threshold_;
    double max_time_in_seconds_;
    ::int64_t max_number_of_iterations_;
    double markowitz_singularity_threshold_;
    ::int32_t markowitz_zlatev_parameter_;
    ::int32_t devex_weights_reset_period_;
    double dual_small_pivot_threshold_;
    double preprocessor_zero_tolerance_;
    double objective_lower_limit_;
    double objective_upper_limit_;
    bool use_middle_product_form_update_;
    bool initialize_devex_with_column_norms_;
    bool exploit_singleton_column_in_initial_basis_;
    bool change_status_to_imprecise_;
    ::int32_t random_seed_;
    double degenerate_ministep_factor_;
    double max_deterministic_time_;
    ::int32_t num_omp_threads_;
    int scaling_method_;
    double drop_tolerance_;
    double relative_cost_perturbation_;
    double relative_max_cost_perturbation_;
    double max_number_of_reoptimizations_;
    double initial_condition_number_threshold_;
    int cost_scaling_;
    bool use_dedicated_dual_feasibility_algorithm_;
    bool dynamically_adjust_refactorization_period_;
    bool push_to_vertex_;
    bool log_to_stdout_;
    double crossover_bound_snapping_distance_;
    double max_valid_magnitude_;
    double drop_magnitude_;
    bool use_implied_free_preprocessor_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fglop_2fparameters_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull GlopParameters_class_data_;
 
// ===================================================================
 
 
 
 
// ===================================================================
 
 
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// GlopParameters
 
// optional .operations_research.glop.GlopParameters.ScalingAlgorithm scaling_method = 57 [default = EQUILIBRATION];
inline bool GlopParameters::has_scaling_method() const {
  bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0;
  return value;
}
inline void GlopParameters::clear_scaling_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.scaling_method_ = 1;
  _impl_._has_bits_[1] &= ~0x00001000u;
}
inline ::operations_research::glop::GlopParameters_ScalingAlgorithm GlopParameters::scaling_method() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.scaling_method)
  return _internal_scaling_method();
}
inline void GlopParameters::set_scaling_method(::operations_research::glop::GlopParameters_ScalingAlgorithm value) {
  _internal_set_scaling_method(value);
  _impl_._has_bits_[1] |= 0x00001000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.scaling_method)
}
inline ::operations_research::glop::GlopParameters_ScalingAlgorithm GlopParameters::_internal_scaling_method() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::glop::GlopParameters_ScalingAlgorithm>(_impl_.scaling_method_);
}
inline void GlopParameters::_internal_set_scaling_method(::operations_research::glop::GlopParameters_ScalingAlgorithm value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::glop::GlopParameters_ScalingAlgorithm_internal_data_));
                                          _impl_.scaling_method_ = value;
}
 
// optional .operations_research.glop.GlopParameters.PricingRule feasibility_rule = 1 [default = STEEPEST_EDGE];
inline bool GlopParameters::has_feasibility_rule() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline void GlopParameters::clear_feasibility_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_rule_ = 1;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::operations_research::glop::GlopParameters_PricingRule GlopParameters::feasibility_rule() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.feasibility_rule)
  return _internal_feasibility_rule();
}
inline void GlopParameters::set_feasibility_rule(::operations_research::glop::GlopParameters_PricingRule value) {
  _internal_set_feasibility_rule(value);
  _impl_._has_bits_[0] |= 0x00000040u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.feasibility_rule)
}
inline ::operations_research::glop::GlopParameters_PricingRule GlopParameters::_internal_feasibility_rule() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::glop::GlopParameters_PricingRule>(_impl_.feasibility_rule_);
}
inline void GlopParameters::_internal_set_feasibility_rule(::operations_research::glop::GlopParameters_PricingRule value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::glop::GlopParameters_PricingRule_internal_data_));
                                          _impl_.feasibility_rule_ = value;
}
 
// optional .operations_research.glop.GlopParameters.PricingRule optimization_rule = 2 [default = STEEPEST_EDGE];
inline bool GlopParameters::has_optimization_rule() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline void GlopParameters::clear_optimization_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.optimization_rule_ = 1;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline ::operations_research::glop::GlopParameters_PricingRule GlopParameters::optimization_rule() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.optimization_rule)
  return _internal_optimization_rule();
}
inline void GlopParameters::set_optimization_rule(::operations_research::glop::GlopParameters_PricingRule value) {
  _internal_set_optimization_rule(value);
  _impl_._has_bits_[0] |= 0x00000080u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.optimization_rule)
}
inline ::operations_research::glop::GlopParameters_PricingRule GlopParameters::_internal_optimization_rule() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::glop::GlopParameters_PricingRule>(_impl_.optimization_rule_);
}
inline void GlopParameters::_internal_set_optimization_rule(::operations_research::glop::GlopParameters_PricingRule value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::glop::GlopParameters_PricingRule_internal_data_));
                                          _impl_.optimization_rule_ = value;
}
 
// optional double refactorization_threshold = 6 [default = 1e-09];
inline bool GlopParameters::has_refactorization_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline void GlopParameters::clear_refactorization_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.refactorization_threshold_ = 1e-09;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline double GlopParameters::refactorization_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.refactorization_threshold)
  return _internal_refactorization_threshold();
}
inline void GlopParameters::set_refactorization_threshold(double value) {
  _internal_set_refactorization_threshold(value);
  _impl_._has_bits_[0] |= 0x00000100u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.refactorization_threshold)
}
inline double GlopParameters::_internal_refactorization_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.refactorization_threshold_;
}
inline void GlopParameters::_internal_set_refactorization_threshold(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.refactorization_threshold_ = value;
}
 
// optional double recompute_reduced_costs_threshold = 8 [default = 1e-08];
inline bool GlopParameters::has_recompute_reduced_costs_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline void GlopParameters::clear_recompute_reduced_costs_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.recompute_reduced_costs_threshold_ = 1e-08;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline double GlopParameters::recompute_reduced_costs_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.recompute_reduced_costs_threshold)
  return _internal_recompute_reduced_costs_threshold();
}
inline void GlopParameters::set_recompute_reduced_costs_threshold(double value) {
  _internal_set_recompute_reduced_costs_threshold(value);
  _impl_._has_bits_[0] |= 0x00000200u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.recompute_reduced_costs_threshold)
}
inline double GlopParameters::_internal_recompute_reduced_costs_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.recompute_reduced_costs_threshold_;
}
inline void GlopParameters::_internal_set_recompute_reduced_costs_threshold(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.recompute_reduced_costs_threshold_ = value;
}
 
// optional double recompute_edges_norm_threshold = 9 [default = 100];
inline bool GlopParameters::has_recompute_edges_norm_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline void GlopParameters::clear_recompute_edges_norm_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.recompute_edges_norm_threshold_ = 100;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline double GlopParameters::recompute_edges_norm_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.recompute_edges_norm_threshold)
  return _internal_recompute_edges_norm_threshold();
}
inline void GlopParameters::set_recompute_edges_norm_threshold(double value) {
  _internal_set_recompute_edges_norm_threshold(value);
  _impl_._has_bits_[0] |= 0x00000400u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.recompute_edges_norm_threshold)
}
inline double GlopParameters::_internal_recompute_edges_norm_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.recompute_edges_norm_threshold_;
}
inline void GlopParameters::_internal_set_recompute_edges_norm_threshold(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.recompute_edges_norm_threshold_ = value;
}
 
// optional double primal_feasibility_tolerance = 10 [default = 1e-08];
inline bool GlopParameters::has_primal_feasibility_tolerance() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline void GlopParameters::clear_primal_feasibility_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.primal_feasibility_tolerance_ = 1e-08;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline double GlopParameters::primal_feasibility_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.primal_feasibility_tolerance)
  return _internal_primal_feasibility_tolerance();
}
inline void GlopParameters::set_primal_feasibility_tolerance(double value) {
  _internal_set_primal_feasibility_tolerance(value);
  _impl_._has_bits_[0] |= 0x00000800u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.primal_feasibility_tolerance)
}
inline double GlopParameters::_internal_primal_feasibility_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.primal_feasibility_tolerance_;
}
inline void GlopParameters::_internal_set_primal_feasibility_tolerance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.primal_feasibility_tolerance_ = value;
}
 
// optional double dual_feasibility_tolerance = 11 [default = 1e-08];
inline bool GlopParameters::has_dual_feasibility_tolerance() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline void GlopParameters::clear_dual_feasibility_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dual_feasibility_tolerance_ = 1e-08;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline double GlopParameters::dual_feasibility_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.dual_feasibility_tolerance)
  return _internal_dual_feasibility_tolerance();
}
inline void GlopParameters::set_dual_feasibility_tolerance(double value) {
  _internal_set_dual_feasibility_tolerance(value);
  _impl_._has_bits_[0] |= 0x00001000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.dual_feasibility_tolerance)
}
inline double GlopParameters::_internal_dual_feasibility_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dual_feasibility_tolerance_;
}
inline void GlopParameters::_internal_set_dual_feasibility_tolerance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dual_feasibility_tolerance_ = value;
}
 
// optional double ratio_test_zero_threshold = 12 [default = 1e-09];
inline bool GlopParameters::has_ratio_test_zero_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline void GlopParameters::clear_ratio_test_zero_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ratio_test_zero_threshold_ = 1e-09;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline double GlopParameters::ratio_test_zero_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.ratio_test_zero_threshold)
  return _internal_ratio_test_zero_threshold();
}
inline void GlopParameters::set_ratio_test_zero_threshold(double value) {
  _internal_set_ratio_test_zero_threshold(value);
  _impl_._has_bits_[0] |= 0x00002000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.ratio_test_zero_threshold)
}
inline double GlopParameters::_internal_ratio_test_zero_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ratio_test_zero_threshold_;
}
inline void GlopParameters::_internal_set_ratio_test_zero_threshold(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ratio_test_zero_threshold_ = value;
}
 
// optional double harris_tolerance_ratio = 13 [default = 0.5];
inline bool GlopParameters::has_harris_tolerance_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline void GlopParameters::clear_harris_tolerance_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.harris_tolerance_ratio_ = 0.5;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline double GlopParameters::harris_tolerance_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.harris_tolerance_ratio)
  return _internal_harris_tolerance_ratio();
}
inline void GlopParameters::set_harris_tolerance_ratio(double value) {
  _internal_set_harris_tolerance_ratio(value);
  _impl_._has_bits_[0] |= 0x00004000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.harris_tolerance_ratio)
}
inline double GlopParameters::_internal_harris_tolerance_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.harris_tolerance_ratio_;
}
inline void GlopParameters::_internal_set_harris_tolerance_ratio(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.harris_tolerance_ratio_ = value;
}
 
// optional double small_pivot_threshold = 14 [default = 1e-06];
inline bool GlopParameters::has_small_pivot_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline void GlopParameters::clear_small_pivot_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.small_pivot_threshold_ = 1e-06;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline double GlopParameters::small_pivot_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.small_pivot_threshold)
  return _internal_small_pivot_threshold();
}
inline void GlopParameters::set_small_pivot_threshold(double value) {
  _internal_set_small_pivot_threshold(value);
  _impl_._has_bits_[0] |= 0x00008000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.small_pivot_threshold)
}
inline double GlopParameters::_internal_small_pivot_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.small_pivot_threshold_;
}
inline void GlopParameters::_internal_set_small_pivot_threshold(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.small_pivot_threshold_ = value;
}
 
// optional double minimum_acceptable_pivot = 15 [default = 1e-06];
inline bool GlopParameters::has_minimum_acceptable_pivot() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline void GlopParameters::clear_minimum_acceptable_pivot() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.minimum_acceptable_pivot_ = 1e-06;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline double GlopParameters::minimum_acceptable_pivot() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.minimum_acceptable_pivot)
  return _internal_minimum_acceptable_pivot();
}
inline void GlopParameters::set_minimum_acceptable_pivot(double value) {
  _internal_set_minimum_acceptable_pivot(value);
  _impl_._has_bits_[0] |= 0x00010000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.minimum_acceptable_pivot)
}
inline double GlopParameters::_internal_minimum_acceptable_pivot() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.minimum_acceptable_pivot_;
}
inline void GlopParameters::_internal_set_minimum_acceptable_pivot(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.minimum_acceptable_pivot_ = value;
}
 
// optional double drop_tolerance = 52 [default = 1e-14];
inline bool GlopParameters::has_drop_tolerance() const {
  bool value = (_impl_._has_bits_[1] & 0x00002000u) != 0;
  return value;
}
inline void GlopParameters::clear_drop_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.drop_tolerance_ = 1e-14;
  _impl_._has_bits_[1] &= ~0x00002000u;
}
inline double GlopParameters::drop_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.drop_tolerance)
  return _internal_drop_tolerance();
}
inline void GlopParameters::set_drop_tolerance(double value) {
  _internal_set_drop_tolerance(value);
  _impl_._has_bits_[1] |= 0x00002000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.drop_tolerance)
}
inline double GlopParameters::_internal_drop_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.drop_tolerance_;
}
inline void GlopParameters::_internal_set_drop_tolerance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.drop_tolerance_ = value;
}
 
// optional bool use_scaling = 16 [default = true];
inline bool GlopParameters::has_use_scaling() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline void GlopParameters::clear_use_scaling() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_scaling_ = true;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline bool GlopParameters::use_scaling() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_scaling)
  return _internal_use_scaling();
}
inline void GlopParameters::set_use_scaling(bool value) {
  _internal_set_use_scaling(value);
  _impl_._has_bits_[0] |= 0x00400000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_scaling)
}
inline bool GlopParameters::_internal_use_scaling() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_scaling_;
}
inline void GlopParameters::_internal_set_use_scaling(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_scaling_ = value;
}
 
// optional .operations_research.glop.GlopParameters.CostScalingAlgorithm cost_scaling = 60 [default = CONTAIN_ONE_COST_SCALING];
inline bool GlopParameters::has_cost_scaling() const {
  bool value = (_impl_._has_bits_[1] & 0x00040000u) != 0;
  return value;
}
inline void GlopParameters::clear_cost_scaling() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cost_scaling_ = 1;
  _impl_._has_bits_[1] &= ~0x00040000u;
}
inline ::operations_research::glop::GlopParameters_CostScalingAlgorithm GlopParameters::cost_scaling() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.cost_scaling)
  return _internal_cost_scaling();
}
inline void GlopParameters::set_cost_scaling(::operations_research::glop::GlopParameters_CostScalingAlgorithm value) {
  _internal_set_cost_scaling(value);
  _impl_._has_bits_[1] |= 0x00040000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.cost_scaling)
}
inline ::operations_research::glop::GlopParameters_CostScalingAlgorithm GlopParameters::_internal_cost_scaling() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::glop::GlopParameters_CostScalingAlgorithm>(_impl_.cost_scaling_);
}
inline void GlopParameters::_internal_set_cost_scaling(::operations_research::glop::GlopParameters_CostScalingAlgorithm value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::glop::GlopParameters_CostScalingAlgorithm_internal_data_));
                                          _impl_.cost_scaling_ = value;
}
 
// optional .operations_research.glop.GlopParameters.InitialBasisHeuristic initial_basis = 17 [default = TRIANGULAR];
inline bool GlopParameters::has_initial_basis() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline void GlopParameters::clear_initial_basis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.initial_basis_ = 2;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline ::operations_research::glop::GlopParameters_InitialBasisHeuristic GlopParameters::initial_basis() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.initial_basis)
  return _internal_initial_basis();
}
inline void GlopParameters::set_initial_basis(::operations_research::glop::GlopParameters_InitialBasisHeuristic value) {
  _internal_set_initial_basis(value);
  _impl_._has_bits_[0] |= 0x00020000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.initial_basis)
}
inline ::operations_research::glop::GlopParameters_InitialBasisHeuristic GlopParameters::_internal_initial_basis() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::glop::GlopParameters_InitialBasisHeuristic>(_impl_.initial_basis_);
}
inline void GlopParameters::_internal_set_initial_basis(::operations_research::glop::GlopParameters_InitialBasisHeuristic value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::glop::GlopParameters_InitialBasisHeuristic_internal_data_));
                                          _impl_.initial_basis_ = value;
}
 
// optional bool use_transposed_matrix = 18 [default = true];
inline bool GlopParameters::has_use_transposed_matrix() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline void GlopParameters::clear_use_transposed_matrix() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_transposed_matrix_ = true;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline bool GlopParameters::use_transposed_matrix() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_transposed_matrix)
  return _internal_use_transposed_matrix();
}
inline void GlopParameters::set_use_transposed_matrix(bool value) {
  _internal_set_use_transposed_matrix(value);
  _impl_._has_bits_[0] |= 0x00800000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_transposed_matrix)
}
inline bool GlopParameters::_internal_use_transposed_matrix() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_transposed_matrix_;
}
inline void GlopParameters::_internal_set_use_transposed_matrix(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_transposed_matrix_ = value;
}
 
// optional int32 basis_refactorization_period = 19 [default = 64];
inline bool GlopParameters::has_basis_refactorization_period() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline void GlopParameters::clear_basis_refactorization_period() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.basis_refactorization_period_ = 64;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline ::int32_t GlopParameters::basis_refactorization_period() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.basis_refactorization_period)
  return _internal_basis_refactorization_period();
}
inline void GlopParameters::set_basis_refactorization_period(::int32_t value) {
  _internal_set_basis_refactorization_period(value);
  _impl_._has_bits_[0] |= 0x00040000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.basis_refactorization_period)
}
inline ::int32_t GlopParameters::_internal_basis_refactorization_period() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.basis_refactorization_period_;
}
inline void GlopParameters::_internal_set_basis_refactorization_period(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.basis_refactorization_period_ = value;
}
 
// optional bool dynamically_adjust_refactorization_period = 63 [default = true];
inline bool GlopParameters::has_dynamically_adjust_refactorization_period() const {
  bool value = (_impl_._has_bits_[1] & 0x00100000u) != 0;
  return value;
}
inline void GlopParameters::clear_dynamically_adjust_refactorization_period() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dynamically_adjust_refactorization_period_ = true;
  _impl_._has_bits_[1] &= ~0x00100000u;
}
inline bool GlopParameters::dynamically_adjust_refactorization_period() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.dynamically_adjust_refactorization_period)
  return _internal_dynamically_adjust_refactorization_period();
}
inline void GlopParameters::set_dynamically_adjust_refactorization_period(bool value) {
  _internal_set_dynamically_adjust_refactorization_period(value);
  _impl_._has_bits_[1] |= 0x00100000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.dynamically_adjust_refactorization_period)
}
inline bool GlopParameters::_internal_dynamically_adjust_refactorization_period() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dynamically_adjust_refactorization_period_;
}
inline void GlopParameters::_internal_set_dynamically_adjust_refactorization_period(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dynamically_adjust_refactorization_period_ = value;
}
 
// optional .operations_research.glop.GlopParameters.SolverBehavior solve_dual_problem = 20 [default = LET_SOLVER_DECIDE];
inline bool GlopParameters::has_solve_dual_problem() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline void GlopParameters::clear_solve_dual_problem() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.solve_dual_problem_ = 2;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline ::operations_research::glop::GlopParameters_SolverBehavior GlopParameters::solve_dual_problem() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.solve_dual_problem)
  return _internal_solve_dual_problem();
}
inline void GlopParameters::set_solve_dual_problem(::operations_research::glop::GlopParameters_SolverBehavior value) {
  _internal_set_solve_dual_problem(value);
  _impl_._has_bits_[0] |= 0x00200000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.solve_dual_problem)
}
inline ::operations_research::glop::GlopParameters_SolverBehavior GlopParameters::_internal_solve_dual_problem() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::glop::GlopParameters_SolverBehavior>(_impl_.solve_dual_problem_);
}
inline void GlopParameters::_internal_set_solve_dual_problem(::operations_research::glop::GlopParameters_SolverBehavior value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::glop::GlopParameters_SolverBehavior_internal_data_));
                                          _impl_.solve_dual_problem_ = value;
}
 
// optional double dualizer_threshold = 21 [default = 1.5];
inline bool GlopParameters::has_dualizer_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline void GlopParameters::clear_dualizer_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dualizer_threshold_ = 1.5;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline double GlopParameters::dualizer_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.dualizer_threshold)
  return _internal_dualizer_threshold();
}
inline void GlopParameters::set_dualizer_threshold(double value) {
  _internal_set_dualizer_threshold(value);
  _impl_._has_bits_[0] |= 0x00080000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.dualizer_threshold)
}
inline double GlopParameters::_internal_dualizer_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dualizer_threshold_;
}
inline void GlopParameters::_internal_set_dualizer_threshold(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dualizer_threshold_ = value;
}
 
// optional double solution_feasibility_tolerance = 22 [default = 1e-06];
inline bool GlopParameters::has_solution_feasibility_tolerance() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline void GlopParameters::clear_solution_feasibility_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.solution_feasibility_tolerance_ = 1e-06;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline double GlopParameters::solution_feasibility_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.solution_feasibility_tolerance)
  return _internal_solution_feasibility_tolerance();
}
inline void GlopParameters::set_solution_feasibility_tolerance(double value) {
  _internal_set_solution_feasibility_tolerance(value);
  _impl_._has_bits_[0] |= 0x00100000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.solution_feasibility_tolerance)
}
inline double GlopParameters::_internal_solution_feasibility_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.solution_feasibility_tolerance_;
}
inline void GlopParameters::_internal_set_solution_feasibility_tolerance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.solution_feasibility_tolerance_ = value;
}
 
// optional bool provide_strong_optimal_guarantee = 24 [default = true];
inline bool GlopParameters::has_provide_strong_optimal_guarantee() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline void GlopParameters::clear_provide_strong_optimal_guarantee() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.provide_strong_optimal_guarantee_ = true;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline bool GlopParameters::provide_strong_optimal_guarantee() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.provide_strong_optimal_guarantee)
  return _internal_provide_strong_optimal_guarantee();
}
inline void GlopParameters::set_provide_strong_optimal_guarantee(bool value) {
  _internal_set_provide_strong_optimal_guarantee(value);
  _impl_._has_bits_[0] |= 0x01000000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.provide_strong_optimal_guarantee)
}
inline bool GlopParameters::_internal_provide_strong_optimal_guarantee() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.provide_strong_optimal_guarantee_;
}
inline void GlopParameters::_internal_set_provide_strong_optimal_guarantee(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.provide_strong_optimal_guarantee_ = value;
}
 
// optional bool change_status_to_imprecise = 58 [default = true];
inline bool GlopParameters::has_change_status_to_imprecise() const {
  bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0;
  return value;
}
inline void GlopParameters::clear_change_status_to_imprecise() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.change_status_to_imprecise_ = true;
  _impl_._has_bits_[1] &= ~0x00000080u;
}
inline bool GlopParameters::change_status_to_imprecise() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.change_status_to_imprecise)
  return _internal_change_status_to_imprecise();
}
inline void GlopParameters::set_change_status_to_imprecise(bool value) {
  _internal_set_change_status_to_imprecise(value);
  _impl_._has_bits_[1] |= 0x00000080u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.change_status_to_imprecise)
}
inline bool GlopParameters::_internal_change_status_to_imprecise() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.change_status_to_imprecise_;
}
inline void GlopParameters::_internal_set_change_status_to_imprecise(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.change_status_to_imprecise_ = value;
}
 
// optional double max_number_of_reoptimizations = 56 [default = 40];
inline bool GlopParameters::has_max_number_of_reoptimizations() const {
  bool value = (_impl_._has_bits_[1] & 0x00010000u) != 0;
  return value;
}
inline void GlopParameters::clear_max_number_of_reoptimizations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_number_of_reoptimizations_ = 40;
  _impl_._has_bits_[1] &= ~0x00010000u;
}
inline double GlopParameters::max_number_of_reoptimizations() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.max_number_of_reoptimizations)
  return _internal_max_number_of_reoptimizations();
}
inline void GlopParameters::set_max_number_of_reoptimizations(double value) {
  _internal_set_max_number_of_reoptimizations(value);
  _impl_._has_bits_[1] |= 0x00010000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.max_number_of_reoptimizations)
}
inline double GlopParameters::_internal_max_number_of_reoptimizations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_number_of_reoptimizations_;
}
inline void GlopParameters::_internal_set_max_number_of_reoptimizations(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_number_of_reoptimizations_ = value;
}
 
// optional double lu_factorization_pivot_threshold = 25 [default = 0.01];
inline bool GlopParameters::has_lu_factorization_pivot_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline void GlopParameters::clear_lu_factorization_pivot_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lu_factorization_pivot_threshold_ = 0.01;
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline double GlopParameters::lu_factorization_pivot_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.lu_factorization_pivot_threshold)
  return _internal_lu_factorization_pivot_threshold();
}
inline void GlopParameters::set_lu_factorization_pivot_threshold(double value) {
  _internal_set_lu_factorization_pivot_threshold(value);
  _impl_._has_bits_[0] |= 0x04000000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.lu_factorization_pivot_threshold)
}
inline double GlopParameters::_internal_lu_factorization_pivot_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.lu_factorization_pivot_threshold_;
}
inline void GlopParameters::_internal_set_lu_factorization_pivot_threshold(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lu_factorization_pivot_threshold_ = value;
}
 
// optional double max_time_in_seconds = 26 [default = inf];
inline bool GlopParameters::has_max_time_in_seconds() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline void GlopParameters::clear_max_time_in_seconds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_time_in_seconds_ = std::numeric_limits<double>::infinity();
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline double GlopParameters::max_time_in_seconds() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.max_time_in_seconds)
  return _internal_max_time_in_seconds();
}
inline void GlopParameters::set_max_time_in_seconds(double value) {
  _internal_set_max_time_in_seconds(value);
  _impl_._has_bits_[0] |= 0x08000000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.max_time_in_seconds)
}
inline double GlopParameters::_internal_max_time_in_seconds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_time_in_seconds_;
}
inline void GlopParameters::_internal_set_max_time_in_seconds(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_time_in_seconds_ = value;
}
 
// optional double max_deterministic_time = 45 [default = inf];
inline bool GlopParameters::has_max_deterministic_time() const {
  bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0;
  return value;
}
inline void GlopParameters::clear_max_deterministic_time() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_deterministic_time_ = std::numeric_limits<double>::infinity();
  _impl_._has_bits_[1] &= ~0x00000400u;
}
inline double GlopParameters::max_deterministic_time() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.max_deterministic_time)
  return _internal_max_deterministic_time();
}
inline void GlopParameters::set_max_deterministic_time(double value) {
  _internal_set_max_deterministic_time(value);
  _impl_._has_bits_[1] |= 0x00000400u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.max_deterministic_time)
}
inline double GlopParameters::_internal_max_deterministic_time() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_deterministic_time_;
}
inline void GlopParameters::_internal_set_max_deterministic_time(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_deterministic_time_ = value;
}
 
// optional int64 max_number_of_iterations = 27 [default = -1];
inline bool GlopParameters::has_max_number_of_iterations() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline void GlopParameters::clear_max_number_of_iterations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_number_of_iterations_ = ::int64_t{-1};
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline ::int64_t GlopParameters::max_number_of_iterations() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.max_number_of_iterations)
  return _internal_max_number_of_iterations();
}
inline void GlopParameters::set_max_number_of_iterations(::int64_t value) {
  _internal_set_max_number_of_iterations(value);
  _impl_._has_bits_[0] |= 0x10000000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.max_number_of_iterations)
}
inline ::int64_t GlopParameters::_internal_max_number_of_iterations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_number_of_iterations_;
}
inline void GlopParameters::_internal_set_max_number_of_iterations(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_number_of_iterations_ = value;
}
 
// optional int32 markowitz_zlatev_parameter = 29 [default = 3];
inline bool GlopParameters::has_markowitz_zlatev_parameter() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline void GlopParameters::clear_markowitz_zlatev_parameter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.markowitz_zlatev_parameter_ = 3;
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline ::int32_t GlopParameters::markowitz_zlatev_parameter() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.markowitz_zlatev_parameter)
  return _internal_markowitz_zlatev_parameter();
}
inline void GlopParameters::set_markowitz_zlatev_parameter(::int32_t value) {
  _internal_set_markowitz_zlatev_parameter(value);
  _impl_._has_bits_[0] |= 0x40000000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.markowitz_zlatev_parameter)
}
inline ::int32_t GlopParameters::_internal_markowitz_zlatev_parameter() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.markowitz_zlatev_parameter_;
}
inline void GlopParameters::_internal_set_markowitz_zlatev_parameter(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.markowitz_zlatev_parameter_ = value;
}
 
// optional double markowitz_singularity_threshold = 30 [default = 1e-15];
inline bool GlopParameters::has_markowitz_singularity_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline void GlopParameters::clear_markowitz_singularity_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.markowitz_singularity_threshold_ = 1e-15;
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline double GlopParameters::markowitz_singularity_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.markowitz_singularity_threshold)
  return _internal_markowitz_singularity_threshold();
}
inline void GlopParameters::set_markowitz_singularity_threshold(double value) {
  _internal_set_markowitz_singularity_threshold(value);
  _impl_._has_bits_[0] |= 0x20000000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.markowitz_singularity_threshold)
}
inline double GlopParameters::_internal_markowitz_singularity_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.markowitz_singularity_threshold_;
}
inline void GlopParameters::_internal_set_markowitz_singularity_threshold(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.markowitz_singularity_threshold_ = value;
}
 
// optional bool use_dual_simplex = 31 [default = false];
inline bool GlopParameters::has_use_dual_simplex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void GlopParameters::clear_use_dual_simplex() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_dual_simplex_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool GlopParameters::use_dual_simplex() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_dual_simplex)
  return _internal_use_dual_simplex();
}
inline void GlopParameters::set_use_dual_simplex(bool value) {
  _internal_set_use_dual_simplex(value);
  _impl_._has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_dual_simplex)
}
inline bool GlopParameters::_internal_use_dual_simplex() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_dual_simplex_;
}
inline void GlopParameters::_internal_set_use_dual_simplex(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_dual_simplex_ = value;
}
 
// optional bool allow_simplex_algorithm_change = 32 [default = false];
inline bool GlopParameters::has_allow_simplex_algorithm_change() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void GlopParameters::clear_allow_simplex_algorithm_change() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_simplex_algorithm_change_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool GlopParameters::allow_simplex_algorithm_change() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.allow_simplex_algorithm_change)
  return _internal_allow_simplex_algorithm_change();
}
inline void GlopParameters::set_allow_simplex_algorithm_change(bool value) {
  _internal_set_allow_simplex_algorithm_change(value);
  _impl_._has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.allow_simplex_algorithm_change)
}
inline bool GlopParameters::_internal_allow_simplex_algorithm_change() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.allow_simplex_algorithm_change_;
}
inline void GlopParameters::_internal_set_allow_simplex_algorithm_change(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_simplex_algorithm_change_ = value;
}
 
// optional int32 devex_weights_reset_period = 33 [default = 150];
inline bool GlopParameters::has_devex_weights_reset_period() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline void GlopParameters::clear_devex_weights_reset_period() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.devex_weights_reset_period_ = 150;
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline ::int32_t GlopParameters::devex_weights_reset_period() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.devex_weights_reset_period)
  return _internal_devex_weights_reset_period();
}
inline void GlopParameters::set_devex_weights_reset_period(::int32_t value) {
  _internal_set_devex_weights_reset_period(value);
  _impl_._has_bits_[0] |= 0x80000000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.devex_weights_reset_period)
}
inline ::int32_t GlopParameters::_internal_devex_weights_reset_period() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.devex_weights_reset_period_;
}
inline void GlopParameters::_internal_set_devex_weights_reset_period(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.devex_weights_reset_period_ = value;
}
 
// optional bool use_preprocessing = 34 [default = true];
inline bool GlopParameters::has_use_preprocessing() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline void GlopParameters::clear_use_preprocessing() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_preprocessing_ = true;
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline bool GlopParameters::use_preprocessing() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_preprocessing)
  return _internal_use_preprocessing();
}
inline void GlopParameters::set_use_preprocessing(bool value) {
  _internal_set_use_preprocessing(value);
  _impl_._has_bits_[0] |= 0x02000000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_preprocessing)
}
inline bool GlopParameters::_internal_use_preprocessing() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_preprocessing_;
}
inline void GlopParameters::_internal_set_use_preprocessing(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_preprocessing_ = value;
}
 
// optional bool use_middle_product_form_update = 35 [default = true];
inline bool GlopParameters::has_use_middle_product_form_update() const {
  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
  return value;
}
inline void GlopParameters::clear_use_middle_product_form_update() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_middle_product_form_update_ = true;
  _impl_._has_bits_[1] &= ~0x00000010u;
}
inline bool GlopParameters::use_middle_product_form_update() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_middle_product_form_update)
  return _internal_use_middle_product_form_update();
}
inline void GlopParameters::set_use_middle_product_form_update(bool value) {
  _internal_set_use_middle_product_form_update(value);
  _impl_._has_bits_[1] |= 0x00000010u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_middle_product_form_update)
}
inline bool GlopParameters::_internal_use_middle_product_form_update() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_middle_product_form_update_;
}
inline void GlopParameters::_internal_set_use_middle_product_form_update(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_middle_product_form_update_ = value;
}
 
// optional bool initialize_devex_with_column_norms = 36 [default = true];
inline bool GlopParameters::has_initialize_devex_with_column_norms() const {
  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
  return value;
}
inline void GlopParameters::clear_initialize_devex_with_column_norms() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.initialize_devex_with_column_norms_ = true;
  _impl_._has_bits_[1] &= ~0x00000020u;
}
inline bool GlopParameters::initialize_devex_with_column_norms() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.initialize_devex_with_column_norms)
  return _internal_initialize_devex_with_column_norms();
}
inline void GlopParameters::set_initialize_devex_with_column_norms(bool value) {
  _internal_set_initialize_devex_with_column_norms(value);
  _impl_._has_bits_[1] |= 0x00000020u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.initialize_devex_with_column_norms)
}
inline bool GlopParameters::_internal_initialize_devex_with_column_norms() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.initialize_devex_with_column_norms_;
}
inline void GlopParameters::_internal_set_initialize_devex_with_column_norms(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.initialize_devex_with_column_norms_ = value;
}
 
// optional bool exploit_singleton_column_in_initial_basis = 37 [default = true];
inline bool GlopParameters::has_exploit_singleton_column_in_initial_basis() const {
  bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0;
  return value;
}
inline void GlopParameters::clear_exploit_singleton_column_in_initial_basis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_singleton_column_in_initial_basis_ = true;
  _impl_._has_bits_[1] &= ~0x00000040u;
}
inline bool GlopParameters::exploit_singleton_column_in_initial_basis() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.exploit_singleton_column_in_initial_basis)
  return _internal_exploit_singleton_column_in_initial_basis();
}
inline void GlopParameters::set_exploit_singleton_column_in_initial_basis(bool value) {
  _internal_set_exploit_singleton_column_in_initial_basis(value);
  _impl_._has_bits_[1] |= 0x00000040u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.exploit_singleton_column_in_initial_basis)
}
inline bool GlopParameters::_internal_exploit_singleton_column_in_initial_basis() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exploit_singleton_column_in_initial_basis_;
}
inline void GlopParameters::_internal_set_exploit_singleton_column_in_initial_basis(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_singleton_column_in_initial_basis_ = value;
}
 
// optional double dual_small_pivot_threshold = 38 [default = 0.0001];
inline bool GlopParameters::has_dual_small_pivot_threshold() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline void GlopParameters::clear_dual_small_pivot_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dual_small_pivot_threshold_ = 0.0001;
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline double GlopParameters::dual_small_pivot_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.dual_small_pivot_threshold)
  return _internal_dual_small_pivot_threshold();
}
inline void GlopParameters::set_dual_small_pivot_threshold(double value) {
  _internal_set_dual_small_pivot_threshold(value);
  _impl_._has_bits_[1] |= 0x00000001u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.dual_small_pivot_threshold)
}
inline double GlopParameters::_internal_dual_small_pivot_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dual_small_pivot_threshold_;
}
inline void GlopParameters::_internal_set_dual_small_pivot_threshold(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dual_small_pivot_threshold_ = value;
}
 
// optional double preprocessor_zero_tolerance = 39 [default = 1e-09];
inline bool GlopParameters::has_preprocessor_zero_tolerance() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline void GlopParameters::clear_preprocessor_zero_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.preprocessor_zero_tolerance_ = 1e-09;
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline double GlopParameters::preprocessor_zero_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.preprocessor_zero_tolerance)
  return _internal_preprocessor_zero_tolerance();
}
inline void GlopParameters::set_preprocessor_zero_tolerance(double value) {
  _internal_set_preprocessor_zero_tolerance(value);
  _impl_._has_bits_[1] |= 0x00000002u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.preprocessor_zero_tolerance)
}
inline double GlopParameters::_internal_preprocessor_zero_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.preprocessor_zero_tolerance_;
}
inline void GlopParameters::_internal_set_preprocessor_zero_tolerance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.preprocessor_zero_tolerance_ = value;
}
 
// optional double objective_lower_limit = 40 [default = -inf];
inline bool GlopParameters::has_objective_lower_limit() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline void GlopParameters::clear_objective_lower_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.objective_lower_limit_ = -std::numeric_limits<double>::infinity();
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline double GlopParameters::objective_lower_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.objective_lower_limit)
  return _internal_objective_lower_limit();
}
inline void GlopParameters::set_objective_lower_limit(double value) {
  _internal_set_objective_lower_limit(value);
  _impl_._has_bits_[1] |= 0x00000004u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.objective_lower_limit)
}
inline double GlopParameters::_internal_objective_lower_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.objective_lower_limit_;
}
inline void GlopParameters::_internal_set_objective_lower_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.objective_lower_limit_ = value;
}
 
// optional double objective_upper_limit = 41 [default = inf];
inline bool GlopParameters::has_objective_upper_limit() const {
  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
  return value;
}
inline void GlopParameters::clear_objective_upper_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.objective_upper_limit_ = std::numeric_limits<double>::infinity();
  _impl_._has_bits_[1] &= ~0x00000008u;
}
inline double GlopParameters::objective_upper_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.objective_upper_limit)
  return _internal_objective_upper_limit();
}
inline void GlopParameters::set_objective_upper_limit(double value) {
  _internal_set_objective_upper_limit(value);
  _impl_._has_bits_[1] |= 0x00000008u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.objective_upper_limit)
}
inline double GlopParameters::_internal_objective_upper_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.objective_upper_limit_;
}
inline void GlopParameters::_internal_set_objective_upper_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.objective_upper_limit_ = value;
}
 
// optional double degenerate_ministep_factor = 42 [default = 0.01];
inline bool GlopParameters::has_degenerate_ministep_factor() const {
  bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0;
  return value;
}
inline void GlopParameters::clear_degenerate_ministep_factor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.degenerate_ministep_factor_ = 0.01;
  _impl_._has_bits_[1] &= ~0x00000200u;
}
inline double GlopParameters::degenerate_ministep_factor() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.degenerate_ministep_factor)
  return _internal_degenerate_ministep_factor();
}
inline void GlopParameters::set_degenerate_ministep_factor(double value) {
  _internal_set_degenerate_ministep_factor(value);
  _impl_._has_bits_[1] |= 0x00000200u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.degenerate_ministep_factor)
}
inline double GlopParameters::_internal_degenerate_ministep_factor() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.degenerate_ministep_factor_;
}
inline void GlopParameters::_internal_set_degenerate_ministep_factor(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.degenerate_ministep_factor_ = value;
}
 
// optional int32 random_seed = 43 [default = 1];
inline bool GlopParameters::has_random_seed() const {
  bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0;
  return value;
}
inline void GlopParameters::clear_random_seed() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.random_seed_ = 1;
  _impl_._has_bits_[1] &= ~0x00000100u;
}
inline ::int32_t GlopParameters::random_seed() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.random_seed)
  return _internal_random_seed();
}
inline void GlopParameters::set_random_seed(::int32_t value) {
  _internal_set_random_seed(value);
  _impl_._has_bits_[1] |= 0x00000100u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.random_seed)
}
inline ::int32_t GlopParameters::_internal_random_seed() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.random_seed_;
}
inline void GlopParameters::_internal_set_random_seed(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.random_seed_ = value;
}
 
// optional bool use_absl_random = 72 [default = false];
inline bool GlopParameters::has_use_absl_random() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline void GlopParameters::clear_use_absl_random() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_absl_random_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool GlopParameters::use_absl_random() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_absl_random)
  return _internal_use_absl_random();
}
inline void GlopParameters::set_use_absl_random(bool value) {
  _internal_set_use_absl_random(value);
  _impl_._has_bits_[0] |= 0x00000020u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_absl_random)
}
inline bool GlopParameters::_internal_use_absl_random() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_absl_random_;
}
inline void GlopParameters::_internal_set_use_absl_random(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_absl_random_ = value;
}
 
// optional int32 num_omp_threads = 44 [default = 1];
inline bool GlopParameters::has_num_omp_threads() const {
  bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0;
  return value;
}
inline void GlopParameters::clear_num_omp_threads() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_omp_threads_ = 1;
  _impl_._has_bits_[1] &= ~0x00000800u;
}
inline ::int32_t GlopParameters::num_omp_threads() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.num_omp_threads)
  return _internal_num_omp_threads();
}
inline void GlopParameters::set_num_omp_threads(::int32_t value) {
  _internal_set_num_omp_threads(value);
  _impl_._has_bits_[1] |= 0x00000800u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.num_omp_threads)
}
inline ::int32_t GlopParameters::_internal_num_omp_threads() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_omp_threads_;
}
inline void GlopParameters::_internal_set_num_omp_threads(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_omp_threads_ = value;
}
 
// optional bool perturb_costs_in_dual_simplex = 53 [default = false];
inline bool GlopParameters::has_perturb_costs_in_dual_simplex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void GlopParameters::clear_perturb_costs_in_dual_simplex() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.perturb_costs_in_dual_simplex_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool GlopParameters::perturb_costs_in_dual_simplex() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.perturb_costs_in_dual_simplex)
  return _internal_perturb_costs_in_dual_simplex();
}
inline void GlopParameters::set_perturb_costs_in_dual_simplex(bool value) {
  _internal_set_perturb_costs_in_dual_simplex(value);
  _impl_._has_bits_[0] |= 0x00000004u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.perturb_costs_in_dual_simplex)
}
inline bool GlopParameters::_internal_perturb_costs_in_dual_simplex() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.perturb_costs_in_dual_simplex_;
}
inline void GlopParameters::_internal_set_perturb_costs_in_dual_simplex(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.perturb_costs_in_dual_simplex_ = value;
}
 
// optional bool use_dedicated_dual_feasibility_algorithm = 62 [default = true];
inline bool GlopParameters::has_use_dedicated_dual_feasibility_algorithm() const {
  bool value = (_impl_._has_bits_[1] & 0x00080000u) != 0;
  return value;
}
inline void GlopParameters::clear_use_dedicated_dual_feasibility_algorithm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_dedicated_dual_feasibility_algorithm_ = true;
  _impl_._has_bits_[1] &= ~0x00080000u;
}
inline bool GlopParameters::use_dedicated_dual_feasibility_algorithm() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_dedicated_dual_feasibility_algorithm)
  return _internal_use_dedicated_dual_feasibility_algorithm();
}
inline void GlopParameters::set_use_dedicated_dual_feasibility_algorithm(bool value) {
  _internal_set_use_dedicated_dual_feasibility_algorithm(value);
  _impl_._has_bits_[1] |= 0x00080000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_dedicated_dual_feasibility_algorithm)
}
inline bool GlopParameters::_internal_use_dedicated_dual_feasibility_algorithm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_dedicated_dual_feasibility_algorithm_;
}
inline void GlopParameters::_internal_set_use_dedicated_dual_feasibility_algorithm(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_dedicated_dual_feasibility_algorithm_ = value;
}
 
// optional double relative_cost_perturbation = 54 [default = 1e-05];
inline bool GlopParameters::has_relative_cost_perturbation() const {
  bool value = (_impl_._has_bits_[1] & 0x00004000u) != 0;
  return value;
}
inline void GlopParameters::clear_relative_cost_perturbation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.relative_cost_perturbation_ = 1e-05;
  _impl_._has_bits_[1] &= ~0x00004000u;
}
inline double GlopParameters::relative_cost_perturbation() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.relative_cost_perturbation)
  return _internal_relative_cost_perturbation();
}
inline void GlopParameters::set_relative_cost_perturbation(double value) {
  _internal_set_relative_cost_perturbation(value);
  _impl_._has_bits_[1] |= 0x00004000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.relative_cost_perturbation)
}
inline double GlopParameters::_internal_relative_cost_perturbation() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.relative_cost_perturbation_;
}
inline void GlopParameters::_internal_set_relative_cost_perturbation(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.relative_cost_perturbation_ = value;
}
 
// optional double relative_max_cost_perturbation = 55 [default = 1e-07];
inline bool GlopParameters::has_relative_max_cost_perturbation() const {
  bool value = (_impl_._has_bits_[1] & 0x00008000u) != 0;
  return value;
}
inline void GlopParameters::clear_relative_max_cost_perturbation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.relative_max_cost_perturbation_ = 1e-07;
  _impl_._has_bits_[1] &= ~0x00008000u;
}
inline double GlopParameters::relative_max_cost_perturbation() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.relative_max_cost_perturbation)
  return _internal_relative_max_cost_perturbation();
}
inline void GlopParameters::set_relative_max_cost_perturbation(double value) {
  _internal_set_relative_max_cost_perturbation(value);
  _impl_._has_bits_[1] |= 0x00008000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.relative_max_cost_perturbation)
}
inline double GlopParameters::_internal_relative_max_cost_perturbation() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.relative_max_cost_perturbation_;
}
inline void GlopParameters::_internal_set_relative_max_cost_perturbation(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.relative_max_cost_perturbation_ = value;
}
 
// optional double initial_condition_number_threshold = 59 [default = 1e+50];
inline bool GlopParameters::has_initial_condition_number_threshold() const {
  bool value = (_impl_._has_bits_[1] & 0x00020000u) != 0;
  return value;
}
inline void GlopParameters::clear_initial_condition_number_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.initial_condition_number_threshold_ = 1e+50;
  _impl_._has_bits_[1] &= ~0x00020000u;
}
inline double GlopParameters::initial_condition_number_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.initial_condition_number_threshold)
  return _internal_initial_condition_number_threshold();
}
inline void GlopParameters::set_initial_condition_number_threshold(double value) {
  _internal_set_initial_condition_number_threshold(value);
  _impl_._has_bits_[1] |= 0x00020000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.initial_condition_number_threshold)
}
inline double GlopParameters::_internal_initial_condition_number_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.initial_condition_number_threshold_;
}
inline void GlopParameters::_internal_set_initial_condition_number_threshold(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.initial_condition_number_threshold_ = value;
}
 
// optional bool log_search_progress = 61 [default = false];
inline bool GlopParameters::has_log_search_progress() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline void GlopParameters::clear_log_search_progress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_search_progress_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool GlopParameters::log_search_progress() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.log_search_progress)
  return _internal_log_search_progress();
}
inline void GlopParameters::set_log_search_progress(bool value) {
  _internal_set_log_search_progress(value);
  _impl_._has_bits_[0] |= 0x00000008u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.log_search_progress)
}
inline bool GlopParameters::_internal_log_search_progress() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.log_search_progress_;
}
inline void GlopParameters::_internal_set_log_search_progress(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_search_progress_ = value;
}
 
// optional bool log_to_stdout = 66 [default = true];
inline bool GlopParameters::has_log_to_stdout() const {
  bool value = (_impl_._has_bits_[1] & 0x00400000u) != 0;
  return value;
}
inline void GlopParameters::clear_log_to_stdout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_to_stdout_ = true;
  _impl_._has_bits_[1] &= ~0x00400000u;
}
inline bool GlopParameters::log_to_stdout() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.log_to_stdout)
  return _internal_log_to_stdout();
}
inline void GlopParameters::set_log_to_stdout(bool value) {
  _internal_set_log_to_stdout(value);
  _impl_._has_bits_[1] |= 0x00400000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.log_to_stdout)
}
inline bool GlopParameters::_internal_log_to_stdout() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.log_to_stdout_;
}
inline void GlopParameters::_internal_set_log_to_stdout(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_to_stdout_ = value;
}
 
// optional double crossover_bound_snapping_distance = 64 [default = inf];
inline bool GlopParameters::has_crossover_bound_snapping_distance() const {
  bool value = (_impl_._has_bits_[1] & 0x00800000u) != 0;
  return value;
}
inline void GlopParameters::clear_crossover_bound_snapping_distance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.crossover_bound_snapping_distance_ = std::numeric_limits<double>::infinity();
  _impl_._has_bits_[1] &= ~0x00800000u;
}
inline double GlopParameters::crossover_bound_snapping_distance() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.crossover_bound_snapping_distance)
  return _internal_crossover_bound_snapping_distance();
}
inline void GlopParameters::set_crossover_bound_snapping_distance(double value) {
  _internal_set_crossover_bound_snapping_distance(value);
  _impl_._has_bits_[1] |= 0x00800000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.crossover_bound_snapping_distance)
}
inline double GlopParameters::_internal_crossover_bound_snapping_distance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.crossover_bound_snapping_distance_;
}
inline void GlopParameters::_internal_set_crossover_bound_snapping_distance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.crossover_bound_snapping_distance_ = value;
}
 
// optional bool push_to_vertex = 65 [default = true];
inline bool GlopParameters::has_push_to_vertex() const {
  bool value = (_impl_._has_bits_[1] & 0x00200000u) != 0;
  return value;
}
inline void GlopParameters::clear_push_to_vertex() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.push_to_vertex_ = true;
  _impl_._has_bits_[1] &= ~0x00200000u;
}
inline bool GlopParameters::push_to_vertex() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.push_to_vertex)
  return _internal_push_to_vertex();
}
inline void GlopParameters::set_push_to_vertex(bool value) {
  _internal_set_push_to_vertex(value);
  _impl_._has_bits_[1] |= 0x00200000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.push_to_vertex)
}
inline bool GlopParameters::_internal_push_to_vertex() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.push_to_vertex_;
}
inline void GlopParameters::_internal_set_push_to_vertex(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.push_to_vertex_ = value;
}
 
// optional bool use_implied_free_preprocessor = 67 [default = true];
inline bool GlopParameters::has_use_implied_free_preprocessor() const {
  bool value = (_impl_._has_bits_[1] & 0x04000000u) != 0;
  return value;
}
inline void GlopParameters::clear_use_implied_free_preprocessor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_implied_free_preprocessor_ = true;
  _impl_._has_bits_[1] &= ~0x04000000u;
}
inline bool GlopParameters::use_implied_free_preprocessor() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_implied_free_preprocessor)
  return _internal_use_implied_free_preprocessor();
}
inline void GlopParameters::set_use_implied_free_preprocessor(bool value) {
  _internal_set_use_implied_free_preprocessor(value);
  _impl_._has_bits_[1] |= 0x04000000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_implied_free_preprocessor)
}
inline bool GlopParameters::_internal_use_implied_free_preprocessor() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_implied_free_preprocessor_;
}
inline void GlopParameters::_internal_set_use_implied_free_preprocessor(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_implied_free_preprocessor_ = value;
}
 
// optional double max_valid_magnitude = 70 [default = 1e+30];
inline bool GlopParameters::has_max_valid_magnitude() const {
  bool value = (_impl_._has_bits_[1] & 0x01000000u) != 0;
  return value;
}
inline void GlopParameters::clear_max_valid_magnitude() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_valid_magnitude_ = 1e+30;
  _impl_._has_bits_[1] &= ~0x01000000u;
}
inline double GlopParameters::max_valid_magnitude() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.max_valid_magnitude)
  return _internal_max_valid_magnitude();
}
inline void GlopParameters::set_max_valid_magnitude(double value) {
  _internal_set_max_valid_magnitude(value);
  _impl_._has_bits_[1] |= 0x01000000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.max_valid_magnitude)
}
inline double GlopParameters::_internal_max_valid_magnitude() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_valid_magnitude_;
}
inline void GlopParameters::_internal_set_max_valid_magnitude(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_valid_magnitude_ = value;
}
 
// optional double drop_magnitude = 71 [default = 1e-30];
inline bool GlopParameters::has_drop_magnitude() const {
  bool value = (_impl_._has_bits_[1] & 0x02000000u) != 0;
  return value;
}
inline void GlopParameters::clear_drop_magnitude() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.drop_magnitude_ = 1e-30;
  _impl_._has_bits_[1] &= ~0x02000000u;
}
inline double GlopParameters::drop_magnitude() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.drop_magnitude)
  return _internal_drop_magnitude();
}
inline void GlopParameters::set_drop_magnitude(double value) {
  _internal_set_drop_magnitude(value);
  _impl_._has_bits_[1] |= 0x02000000u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.drop_magnitude)
}
inline double GlopParameters::_internal_drop_magnitude() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.drop_magnitude_;
}
inline void GlopParameters::_internal_set_drop_magnitude(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.drop_magnitude_ = value;
}
 
// optional bool dual_price_prioritize_norm = 69 [default = false];
inline bool GlopParameters::has_dual_price_prioritize_norm() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline void GlopParameters::clear_dual_price_prioritize_norm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dual_price_prioritize_norm_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool GlopParameters::dual_price_prioritize_norm() const {
  // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.dual_price_prioritize_norm)
  return _internal_dual_price_prioritize_norm();
}
inline void GlopParameters::set_dual_price_prioritize_norm(bool value) {
  _internal_set_dual_price_prioritize_norm(value);
  _impl_._has_bits_[0] |= 0x00000010u;
  // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.dual_price_prioritize_norm)
}
inline bool GlopParameters::_internal_dual_price_prioritize_norm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dual_price_prioritize_norm_;
}
inline void GlopParameters::_internal_set_dual_price_prioritize_norm(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dual_price_prioritize_norm_ = value;
}
 
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__
 
// @@protoc_insertion_point(namespace_scope)
}  // namespace glop
}  // namespace operations_research
 
 
namespace google {
namespace protobuf {
 
template <>
struct is_proto_enum<::operations_research::glop::GlopParameters_ScalingAlgorithm> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_ScalingAlgorithm>() {
  return ::operations_research::glop::GlopParameters_ScalingAlgorithm_descriptor();
}
template <>
struct is_proto_enum<::operations_research::glop::GlopParameters_SolverBehavior> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_SolverBehavior>() {
  return ::operations_research::glop::GlopParameters_SolverBehavior_descriptor();
}
template <>
struct is_proto_enum<::operations_research::glop::GlopParameters_PricingRule> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_PricingRule>() {
  return ::operations_research::glop::GlopParameters_PricingRule_descriptor();
}
template <>
struct is_proto_enum<::operations_research::glop::GlopParameters_InitialBasisHeuristic> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_InitialBasisHeuristic>() {
  return ::operations_research::glop::GlopParameters_InitialBasisHeuristic_descriptor();
}
template <>
struct is_proto_enum<::operations_research::glop::GlopParameters_CostScalingAlgorithm> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_CostScalingAlgorithm>() {
  return ::operations_research::glop::GlopParameters_CostScalingAlgorithm_descriptor();
}
 
}  // namespace protobuf
}  // namespace google
 
// @@protoc_insertion_point(global_scope)
 
#include "google/protobuf/port_undef.inc"
 
#endif  // ortools_2fglop_2fparameters_2eproto_2epb_2eh