text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: ortools/constraint_solver/routing_enums.proto
  
  #ifndef GOOGLE_PROTOBUF_INCLUDED_ortools_2fconstraint_5fsolver_2frouting_5fenums_2eproto
  #define GOOGLE_PROTOBUF_INCLUDED_ortools_2fconstraint_5fsolver_2frouting_5fenums_2eproto
  
  #include <limits>
  #include <string>
  
  #include <google/protobuf/port_def.inc>
  #if PROTOBUF_VERSION < 3018000
  #error This file was generated by a newer version of protoc which is
  #error incompatible with your Protocol Buffer headers. Please update
  #error your headers.
  #endif
  #if 3018000 < PROTOBUF_MIN_PROTOC_VERSION
  #error This file was generated by an older version of protoc which is
  #error incompatible with your Protocol Buffer headers. Please
  #error regenerate this file with a newer version of protoc.
  #endif
  
  #include <google/protobuf/port_undef.inc>
  #include <google/protobuf/io/coded_stream.h>
  #include <google/protobuf/arena.h>
  #include <google/protobuf/arenastring.h>
  #include <google/protobuf/generated_message_bases.h>
  #include <google/protobuf/generated_message_table_driven.h>
  #include <google/protobuf/generated_message_util.h>
  #include <google/protobuf/metadata_lite.h>
  #include <google/protobuf/generated_message_reflection.h>
  #include <google/protobuf/message.h>
  #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
  #include <google/protobuf/extension_set.h>  // IWYU pragma: export
  #include <google/protobuf/generated_enum_reflection.h>
  #include <google/protobuf/unknown_field_set.h>
  // @@protoc_insertion_point(includes)
  #include <google/protobuf/port_def.inc>
  #define PROTOBUF_INTERNAL_EXPORT_ortools_2fconstraint_5fsolver_2frouting_5fenums_2eproto
  PROTOBUF_NAMESPACE_OPEN
  namespace internal {
  class AnyMetadata;
  }  // namespace internal
  PROTOBUF_NAMESPACE_CLOSE
  
  // Internal implementation detail -- do not use these members.
  struct TableStruct_ortools_2fconstraint_5fsolver_2frouting_5fenums_2eproto {
    static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
    static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
    static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
  };
  extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2fconstraint_5fsolver_2frouting_5fenums_2eproto;
  namespace operations_research {
  class FirstSolutionStrategy;
  struct FirstSolutionStrategyDefaultTypeInternal;
  extern FirstSolutionStrategyDefaultTypeInternal _FirstSolutionStrategy_default_instance_;
  class LocalSearchMetaheuristic;
  struct LocalSearchMetaheuristicDefaultTypeInternal;
  extern LocalSearchMetaheuristicDefaultTypeInternal _LocalSearchMetaheuristic_default_instance_;
  }  // namespace operations_research
  PROTOBUF_NAMESPACE_OPEN
  template<> ::operations_research::FirstSolutionStrategy* Arena::CreateMaybeMessage<::operations_research::FirstSolutionStrategy>(Arena*);
  template<> ::operations_research::LocalSearchMetaheuristic* Arena::CreateMaybeMessage<::operations_research::LocalSearchMetaheuristic>(Arena*);
  PROTOBUF_NAMESPACE_CLOSE
  namespace operations_research {
  
  enum FirstSolutionStrategy_Value : int {
    FirstSolutionStrategy_Value_UNSET = 0,
    FirstSolutionStrategy_Value_AUTOMATIC = 15,
    FirstSolutionStrategy_Value_PATH_CHEAPEST_ARC = 3,
    FirstSolutionStrategy_Value_PATH_MOST_CONSTRAINED_ARC = 4,
    FirstSolutionStrategy_Value_EVALUATOR_STRATEGY = 5,
    FirstSolutionStrategy_Value_SAVINGS = 10,
    FirstSolutionStrategy_Value_SWEEP = 11,
    FirstSolutionStrategy_Value_CHRISTOFIDES = 13,
    FirstSolutionStrategy_Value_ALL_UNPERFORMED = 6,
    FirstSolutionStrategy_Value_BEST_INSERTION = 7,
    FirstSolutionStrategy_Value_PARALLEL_CHEAPEST_INSERTION = 8,
    FirstSolutionStrategy_Value_SEQUENTIAL_CHEAPEST_INSERTION = 14,
    FirstSolutionStrategy_Value_LOCAL_CHEAPEST_INSERTION = 9,
    FirstSolutionStrategy_Value_GLOBAL_CHEAPEST_ARC = 1,
    FirstSolutionStrategy_Value_LOCAL_CHEAPEST_ARC = 2,
    FirstSolutionStrategy_Value_FIRST_UNBOUND_MIN_VALUE = 12,
    FirstSolutionStrategy_Value_FirstSolutionStrategy_Value_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    FirstSolutionStrategy_Value_FirstSolutionStrategy_Value_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool FirstSolutionStrategy_Value_IsValid(int value);
  constexpr FirstSolutionStrategy_Value FirstSolutionStrategy_Value_Value_MIN = FirstSolutionStrategy_Value_UNSET;
  constexpr FirstSolutionStrategy_Value FirstSolutionStrategy_Value_Value_MAX = FirstSolutionStrategy_Value_AUTOMATIC;
  constexpr int FirstSolutionStrategy_Value_Value_ARRAYSIZE = FirstSolutionStrategy_Value_Value_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FirstSolutionStrategy_Value_descriptor();
  template<typename T>
  inline const std::string& FirstSolutionStrategy_Value_Name(T enum_t_value) {
    static_assert(::std::is_same<T, FirstSolutionStrategy_Value>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function FirstSolutionStrategy_Value_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      FirstSolutionStrategy_Value_descriptor(), enum_t_value);
  }
  inline bool FirstSolutionStrategy_Value_Parse(
      ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FirstSolutionStrategy_Value* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FirstSolutionStrategy_Value>(
      FirstSolutionStrategy_Value_descriptor(), name, value);
  }
  enum LocalSearchMetaheuristic_Value : int {
    LocalSearchMetaheuristic_Value_UNSET = 0,
    LocalSearchMetaheuristic_Value_AUTOMATIC = 6,
    LocalSearchMetaheuristic_Value_GREEDY_DESCENT = 1,
    LocalSearchMetaheuristic_Value_GUIDED_LOCAL_SEARCH = 2,
    LocalSearchMetaheuristic_Value_SIMULATED_ANNEALING = 3,
    LocalSearchMetaheuristic_Value_TABU_SEARCH = 4,
    LocalSearchMetaheuristic_Value_GENERIC_TABU_SEARCH = 5,
    LocalSearchMetaheuristic_Value_LocalSearchMetaheuristic_Value_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    LocalSearchMetaheuristic_Value_LocalSearchMetaheuristic_Value_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool LocalSearchMetaheuristic_Value_IsValid(int value);
  constexpr LocalSearchMetaheuristic_Value LocalSearchMetaheuristic_Value_Value_MIN = LocalSearchMetaheuristic_Value_UNSET;
  constexpr LocalSearchMetaheuristic_Value LocalSearchMetaheuristic_Value_Value_MAX = LocalSearchMetaheuristic_Value_AUTOMATIC;
  constexpr int LocalSearchMetaheuristic_Value_Value_ARRAYSIZE = LocalSearchMetaheuristic_Value_Value_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LocalSearchMetaheuristic_Value_descriptor();
  template<typename T>
  inline const std::string& LocalSearchMetaheuristic_Value_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LocalSearchMetaheuristic_Value>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LocalSearchMetaheuristic_Value_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      LocalSearchMetaheuristic_Value_descriptor(), enum_t_value);
  }
  inline bool LocalSearchMetaheuristic_Value_Parse(
      ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LocalSearchMetaheuristic_Value* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LocalSearchMetaheuristic_Value>(
      LocalSearchMetaheuristic_Value_descriptor(), name, value);
  }
  // ===================================================================
  
  class FirstSolutionStrategy final :
      public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:operations_research.FirstSolutionStrategy) */ {
   public:
    inline FirstSolutionStrategy() : FirstSolutionStrategy(nullptr) {}
    explicit constexpr FirstSolutionStrategy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  
    FirstSolutionStrategy(const FirstSolutionStrategy& from);
    FirstSolutionStrategy(FirstSolutionStrategy&& from) noexcept
      : FirstSolutionStrategy() {
      *this = ::std::move(from);
    }
  
    inline FirstSolutionStrategy& operator=(const FirstSolutionStrategy& from) {
      CopyFrom(from);
      return *this;
    }
    inline FirstSolutionStrategy& operator=(FirstSolutionStrategy&& from) noexcept {
      if (this == &from) return *this;
      if (GetOwningArena() == from.GetOwningArena()
    #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
          && GetOwningArena() != nullptr
    #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
      ) {
        InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return default_instance().GetMetadata().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return default_instance().GetMetadata().reflection;
    }
    static const FirstSolutionStrategy& default_instance() {
      return *internal_default_instance();
    }
    static inline const FirstSolutionStrategy* internal_default_instance() {
      return reinterpret_cast<const FirstSolutionStrategy*>(
                 &_FirstSolutionStrategy_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      0;
  
    friend void swap(FirstSolutionStrategy& a, FirstSolutionStrategy& b) {
      a.Swap(&b);
    }
    inline void Swap(FirstSolutionStrategy* other) {
      if (other == this) return;
      if (GetOwningArena() == other->GetOwningArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(FirstSolutionStrategy* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline FirstSolutionStrategy* New() const final {
      return new FirstSolutionStrategy();
    }
  
    FirstSolutionStrategy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<FirstSolutionStrategy>(arena);
    }
    using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
    inline void CopyFrom(const FirstSolutionStrategy& from) {
      ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
    }
    using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
    void MergeFrom(const FirstSolutionStrategy& from) {
      ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
    }
    public:
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "operations_research.FirstSolutionStrategy";
    }
    protected:
    explicit FirstSolutionStrategy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned = false);
    private:
    public:
  
    static const ClassData _class_data_;
    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    typedef FirstSolutionStrategy_Value Value;
    static constexpr Value UNSET =
      FirstSolutionStrategy_Value_UNSET;
    static constexpr Value AUTOMATIC =
      FirstSolutionStrategy_Value_AUTOMATIC;
    static constexpr Value PATH_CHEAPEST_ARC =
      FirstSolutionStrategy_Value_PATH_CHEAPEST_ARC;
    static constexpr Value PATH_MOST_CONSTRAINED_ARC =
      FirstSolutionStrategy_Value_PATH_MOST_CONSTRAINED_ARC;
    static constexpr Value EVALUATOR_STRATEGY =
      FirstSolutionStrategy_Value_EVALUATOR_STRATEGY;
    static constexpr Value SAVINGS =
      FirstSolutionStrategy_Value_SAVINGS;
    static constexpr Value SWEEP =
      FirstSolutionStrategy_Value_SWEEP;
    static constexpr Value CHRISTOFIDES =
      FirstSolutionStrategy_Value_CHRISTOFIDES;
    static constexpr Value ALL_UNPERFORMED =
      FirstSolutionStrategy_Value_ALL_UNPERFORMED;
    static constexpr Value BEST_INSERTION =
      FirstSolutionStrategy_Value_BEST_INSERTION;
    static constexpr Value PARALLEL_CHEAPEST_INSERTION =
      FirstSolutionStrategy_Value_PARALLEL_CHEAPEST_INSERTION;
    static constexpr Value SEQUENTIAL_CHEAPEST_INSERTION =
      FirstSolutionStrategy_Value_SEQUENTIAL_CHEAPEST_INSERTION;
    static constexpr Value LOCAL_CHEAPEST_INSERTION =
      FirstSolutionStrategy_Value_LOCAL_CHEAPEST_INSERTION;
    static constexpr Value GLOBAL_CHEAPEST_ARC =
      FirstSolutionStrategy_Value_GLOBAL_CHEAPEST_ARC;
    static constexpr Value LOCAL_CHEAPEST_ARC =
      FirstSolutionStrategy_Value_LOCAL_CHEAPEST_ARC;
    static constexpr Value FIRST_UNBOUND_MIN_VALUE =
      FirstSolutionStrategy_Value_FIRST_UNBOUND_MIN_VALUE;
    static inline bool Value_IsValid(int value) {
      return FirstSolutionStrategy_Value_IsValid(value);
    }
    static constexpr Value Value_MIN =
      FirstSolutionStrategy_Value_Value_MIN;
    static constexpr Value Value_MAX =
      FirstSolutionStrategy_Value_Value_MAX;
    static constexpr int Value_ARRAYSIZE =
      FirstSolutionStrategy_Value_Value_ARRAYSIZE;
    static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
    Value_descriptor() {
      return FirstSolutionStrategy_Value_descriptor();
    }
    template<typename T>
    static inline const std::string& Value_Name(T enum_t_value) {
      static_assert(::std::is_same<T, Value>::value ||
        ::std::is_integral<T>::value,
        "Incorrect type passed to function Value_Name.");
      return FirstSolutionStrategy_Value_Name(enum_t_value);
    }
    static inline bool Value_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
        Value* value) {
      return FirstSolutionStrategy_Value_Parse(name, value);
    }
  
    // accessors -------------------------------------------------------
  
    // @@protoc_insertion_point(class_scope:operations_research.FirstSolutionStrategy)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_ortools_2fconstraint_5fsolver_2frouting_5fenums_2eproto;
  };
  // -------------------------------------------------------------------
  
  class LocalSearchMetaheuristic final :
      public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:operations_research.LocalSearchMetaheuristic) */ {
   public:
    inline LocalSearchMetaheuristic() : LocalSearchMetaheuristic(nullptr) {}
    explicit constexpr LocalSearchMetaheuristic(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  
    LocalSearchMetaheuristic(const LocalSearchMetaheuristic& from);
    LocalSearchMetaheuristic(LocalSearchMetaheuristic&& from) noexcept
      : LocalSearchMetaheuristic() {
      *this = ::std::move(from);
    }
  
    inline LocalSearchMetaheuristic& operator=(const LocalSearchMetaheuristic& from) {
      CopyFrom(from);
      return *this;
    }
    inline LocalSearchMetaheuristic& operator=(LocalSearchMetaheuristic&& from) noexcept {
      if (this == &from) return *this;
      if (GetOwningArena() == from.GetOwningArena()
    #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
          && GetOwningArena() != nullptr
    #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
      ) {
        InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return default_instance().GetMetadata().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return default_instance().GetMetadata().reflection;
    }
    static const LocalSearchMetaheuristic& default_instance() {
      return *internal_default_instance();
    }
    static inline const LocalSearchMetaheuristic* internal_default_instance() {
      return reinterpret_cast<const LocalSearchMetaheuristic*>(
                 &_LocalSearchMetaheuristic_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      1;
  
    friend void swap(LocalSearchMetaheuristic& a, LocalSearchMetaheuristic& b) {
      a.Swap(&b);
    }
    inline void Swap(LocalSearchMetaheuristic* other) {
      if (other == this) return;
      if (GetOwningArena() == other->GetOwningArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(LocalSearchMetaheuristic* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline LocalSearchMetaheuristic* New() const final {
      return new LocalSearchMetaheuristic();
    }
  
    LocalSearchMetaheuristic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<LocalSearchMetaheuristic>(arena);
    }
    using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
    inline void CopyFrom(const LocalSearchMetaheuristic& from) {
      ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
    }
    using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
    void MergeFrom(const LocalSearchMetaheuristic& from) {
      ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
    }
    public:
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "operations_research.LocalSearchMetaheuristic";
    }
    protected:
    explicit LocalSearchMetaheuristic(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned = false);
    private:
    public:
  
    static const ClassData _class_data_;
    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    typedef LocalSearchMetaheuristic_Value Value;
    static constexpr Value UNSET =
      LocalSearchMetaheuristic_Value_UNSET;
    static constexpr Value AUTOMATIC =
      LocalSearchMetaheuristic_Value_AUTOMATIC;
    static constexpr Value GREEDY_DESCENT =
      LocalSearchMetaheuristic_Value_GREEDY_DESCENT;
    static constexpr Value GUIDED_LOCAL_SEARCH =
      LocalSearchMetaheuristic_Value_GUIDED_LOCAL_SEARCH;
    static constexpr Value SIMULATED_ANNEALING =
      LocalSearchMetaheuristic_Value_SIMULATED_ANNEALING;
    static constexpr Value TABU_SEARCH =
      LocalSearchMetaheuristic_Value_TABU_SEARCH;
    static constexpr Value GENERIC_TABU_SEARCH =
      LocalSearchMetaheuristic_Value_GENERIC_TABU_SEARCH;
    static inline bool Value_IsValid(int value) {
      return LocalSearchMetaheuristic_Value_IsValid(value);
    }
    static constexpr Value Value_MIN =
      LocalSearchMetaheuristic_Value_Value_MIN;
    static constexpr Value Value_MAX =
      LocalSearchMetaheuristic_Value_Value_MAX;
    static constexpr int Value_ARRAYSIZE =
      LocalSearchMetaheuristic_Value_Value_ARRAYSIZE;
    static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
    Value_descriptor() {
      return LocalSearchMetaheuristic_Value_descriptor();
    }
    template<typename T>
    static inline const std::string& Value_Name(T enum_t_value) {
      static_assert(::std::is_same<T, Value>::value ||
        ::std::is_integral<T>::value,
        "Incorrect type passed to function Value_Name.");
      return LocalSearchMetaheuristic_Value_Name(enum_t_value);
    }
    static inline bool Value_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
        Value* value) {
      return LocalSearchMetaheuristic_Value_Parse(name, value);
    }
  
    // accessors -------------------------------------------------------
  
    // @@protoc_insertion_point(class_scope:operations_research.LocalSearchMetaheuristic)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_ortools_2fconstraint_5fsolver_2frouting_5fenums_2eproto;
  };
  // ===================================================================
  
  
  // ===================================================================
  
  #ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wstrict-aliasing"
  #endif  // __GNUC__
  // FirstSolutionStrategy
  
  // -------------------------------------------------------------------
  
  // LocalSearchMetaheuristic
  
  #ifdef __GNUC__
    #pragma GCC diagnostic pop
  #endif  // __GNUC__
  // -------------------------------------------------------------------
  
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace operations_research
  
  PROTOBUF_NAMESPACE_OPEN
  
  template <> struct is_proto_enum< ::operations_research::FirstSolutionStrategy_Value> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::FirstSolutionStrategy_Value>() {
    return ::operations_research::FirstSolutionStrategy_Value_descriptor();
  }
  template <> struct is_proto_enum< ::operations_research::LocalSearchMetaheuristic_Value> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::LocalSearchMetaheuristic_Value>() {
    return ::operations_research::LocalSearchMetaheuristic_Value_descriptor();
  }
  
  PROTOBUF_NAMESPACE_CLOSE
  
  // @@protoc_insertion_point(global_scope)
  
  #include <google/protobuf/port_undef.inc>
  #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_ortools_2fconstraint_5fsolver_2frouting_5fenums_2eproto
  