// Generated by the protocol buffer compiler.  DO NOT EDIT!

// source: net_fuzzer.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_net_5ffuzzer_2eproto

#define GOOGLE_PROTOBUF_INCLUDED_net_5ffuzzer_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 3018001 < 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_net_5ffuzzer_2eproto

PROTOBUF_NAMESPACE_OPEN

namespace internal {

class AnyMetadata;

}  // namespace internal

PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.

struct TableStruct_net_5ffuzzer_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[62]

    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_net_5ffuzzer_2eproto;

class Accept;

struct AcceptDefaultTypeInternal;

extern AcceptDefaultTypeInternal _Accept_default_instance_;

class AcceptNocancel;

struct AcceptNocancelDefaultTypeInternal;

extern AcceptNocancelDefaultTypeInternal _AcceptNocancel_default_instance_;

class Bind;

struct BindDefaultTypeInternal;

extern BindDefaultTypeInternal _Bind_default_instance_;

class ClearAll;

struct ClearAllDefaultTypeInternal;

extern ClearAllDefaultTypeInternal _ClearAll_default_instance_;

class Close;

struct CloseDefaultTypeInternal;

extern CloseDefaultTypeInternal _Close_default_instance_;

class Command;

struct CommandDefaultTypeInternal;

extern CommandDefaultTypeInternal _Command_default_instance_;

class Connect;

struct ConnectDefaultTypeInternal;

extern ConnectDefaultTypeInternal _Connect_default_instance_;

class ConnectNocancel;

struct ConnectNocancelDefaultTypeInternal;

extern ConnectNocancelDefaultTypeInternal _ConnectNocancel_default_instance_;

class ConnectX;

struct ConnectXDefaultTypeInternal;

extern ConnectXDefaultTypeInternal _ConnectX_default_instance_;

class DisconnectX;

struct DisconnectXDefaultTypeInternal;

extern DisconnectXDefaultTypeInternal _DisconnectX_default_instance_;

class Endpoints;

struct EndpointsDefaultTypeInternal;

extern EndpointsDefaultTypeInternal _Endpoints_default_instance_;

class GetSocketOpt;

struct GetSocketOptDefaultTypeInternal;

extern GetSocketOptDefaultTypeInternal _GetSocketOpt_default_instance_;

class Getpeername;

struct GetpeernameDefaultTypeInternal;

extern GetpeernameDefaultTypeInternal _Getpeername_default_instance_;

class Getsockname;

struct GetsocknameDefaultTypeInternal;

extern GetsocknameDefaultTypeInternal _Getsockname_default_instance_;

class IOV;

struct IOVDefaultTypeInternal;

extern IOVDefaultTypeInternal _IOV_default_instance_;

class Icmp6Hdr;

struct Icmp6HdrDefaultTypeInternal;

extern Icmp6HdrDefaultTypeInternal _Icmp6Hdr_default_instance_;

class IfReqFlags;

struct IfReqFlagsDefaultTypeInternal;

extern IfReqFlagsDefaultTypeInternal _IfReqFlags_default_instance_;

class In6AddrLifetime_64;

struct In6AddrLifetime_64DefaultTypeInternal;

extern In6AddrLifetime_64DefaultTypeInternal _In6AddrLifetime_64_default_instance_;

class In6_AliasReq_64;

struct In6_AliasReq_64DefaultTypeInternal;

extern In6_AliasReq_64DefaultTypeInternal _In6_AliasReq_64_default_instance_;

class Ioctl;

struct IoctlDefaultTypeInternal;

extern IoctlDefaultTypeInternal _Ioctl_default_instance_;

class IoctlReal;

struct IoctlRealDefaultTypeInternal;

extern IoctlRealDefaultTypeInternal _IoctlReal_default_instance_;

class Ip4Packet;

struct Ip4PacketDefaultTypeInternal;

extern Ip4PacketDefaultTypeInternal _Ip4Packet_default_instance_;

class Ip6Ext;

struct Ip6ExtDefaultTypeInternal;

extern Ip6ExtDefaultTypeInternal _Ip6Ext_default_instance_;

class Ip6FragHdr;

struct Ip6FragHdrDefaultTypeInternal;

extern Ip6FragHdrDefaultTypeInternal _Ip6FragHdr_default_instance_;

class Ip6Hdr;

struct Ip6HdrDefaultTypeInternal;

extern Ip6HdrDefaultTypeInternal _Ip6Hdr_default_instance_;

class Ip6Hdrctl;

struct Ip6HdrctlDefaultTypeInternal;

extern Ip6HdrctlDefaultTypeInternal _Ip6Hdrctl_default_instance_;

class Ip6Packet;

struct Ip6PacketDefaultTypeInternal;

extern Ip6PacketDefaultTypeInternal _Ip6Packet_default_instance_;

class Ip6Rt0Hdr;

struct Ip6Rt0HdrDefaultTypeInternal;

extern Ip6Rt0HdrDefaultTypeInternal _Ip6Rt0Hdr_default_instance_;

class Ip6RtHdr;

struct Ip6RtHdrDefaultTypeInternal;

extern Ip6RtHdrDefaultTypeInternal _Ip6RtHdr_default_instance_;

class IpHdr;

struct IpHdrDefaultTypeInternal;

extern IpHdrDefaultTypeInternal _IpHdr_default_instance_;

class Key;

struct KeyDefaultTypeInternal;

extern KeyDefaultTypeInternal _Key_default_instance_;

class Listen;

struct ListenDefaultTypeInternal;

extern ListenDefaultTypeInternal _Listen_default_instance_;

class NecpClientAction;

struct NecpClientActionDefaultTypeInternal;

extern NecpClientActionDefaultTypeInternal _NecpClientAction_default_instance_;

class NecpClientActionAdd;

struct NecpClientActionAddDefaultTypeInternal;

extern NecpClientActionAddDefaultTypeInternal _NecpClientActionAdd_default_instance_;

class NecpClientActionAgent;

struct NecpClientActionAgentDefaultTypeInternal;

extern NecpClientActionAgentDefaultTypeInternal _NecpClientActionAgent_default_instance_;

class NecpClientActionCopyParameters;

struct NecpClientActionCopyParametersDefaultTypeInternal;

extern NecpClientActionCopyParametersDefaultTypeInternal _NecpClientActionCopyParameters_default_instance_;

class NecpClientActionRemove;

struct NecpClientActionRemoveDefaultTypeInternal;

extern NecpClientActionRemoveDefaultTypeInternal _NecpClientActionRemove_default_instance_;

class NecpMatchPolicy;

struct NecpMatchPolicyDefaultTypeInternal;

extern NecpMatchPolicyDefaultTypeInternal _NecpMatchPolicy_default_instance_;

class NecpOpen;

struct NecpOpenDefaultTypeInternal;

extern NecpOpenDefaultTypeInternal _NecpOpen_default_instance_;

class NecpSessionAction;

struct NecpSessionActionDefaultTypeInternal;

extern NecpSessionActionDefaultTypeInternal _NecpSessionAction_default_instance_;

class NecpSessionOpen;

struct NecpSessionOpenDefaultTypeInternal;

extern NecpSessionOpenDefaultTypeInternal _NecpSessionOpen_default_instance_;

class NecpTlv;

struct NecpTlvDefaultTypeInternal;

extern NecpTlvDefaultTypeInternal _NecpTlv_default_instance_;

class Packet;

struct PacketDefaultTypeInternal;

extern PacketDefaultTypeInternal _Packet_default_instance_;

class Peeloff;

struct PeeloffDefaultTypeInternal;

extern PeeloffDefaultTypeInternal _Peeloff_default_instance_;

class Pipe;

struct PipeDefaultTypeInternal;

extern PipeDefaultTypeInternal _Pipe_default_instance_;

class Recvfrom;

struct RecvfromDefaultTypeInternal;

extern RecvfromDefaultTypeInternal _Recvfrom_default_instance_;

class RecvfromNocancel;

struct RecvfromNocancelDefaultTypeInternal;

extern RecvfromNocancelDefaultTypeInternal _RecvfromNocancel_default_instance_;

class Recvmsg;

struct RecvmsgDefaultTypeInternal;

extern RecvmsgDefaultTypeInternal _Recvmsg_default_instance_;

class Sendmsg;

struct SendmsgDefaultTypeInternal;

extern SendmsgDefaultTypeInternal _Sendmsg_default_instance_;

class Sendto;

struct SendtoDefaultTypeInternal;

extern SendtoDefaultTypeInternal _Sendto_default_instance_;

class Session;

struct SessionDefaultTypeInternal;

extern SessionDefaultTypeInternal _Session_default_instance_;

class SetSocketOpt;

struct SetSocketOptDefaultTypeInternal;

extern SetSocketOptDefaultTypeInternal _SetSocketOpt_default_instance_;

class Shutdown;

struct ShutdownDefaultTypeInternal;

extern ShutdownDefaultTypeInternal _Shutdown_default_instance_;

class SockAddr;

struct SockAddrDefaultTypeInternal;

extern SockAddrDefaultTypeInternal _SockAddr_default_instance_;

class SockAddr4;

struct SockAddr4DefaultTypeInternal;

extern SockAddr4DefaultTypeInternal _SockAddr4_default_instance_;

class SockAddr6;

struct SockAddr6DefaultTypeInternal;

extern SockAddr6DefaultTypeInternal _SockAddr6_default_instance_;

class SockAddrGeneric;

struct SockAddrGenericDefaultTypeInternal;

extern SockAddrGenericDefaultTypeInternal _SockAddrGeneric_default_instance_;

class Socket;

struct SocketDefaultTypeInternal;

extern SocketDefaultTypeInternal _Socket_default_instance_;

class Socketpair;

struct SocketpairDefaultTypeInternal;

extern SocketpairDefaultTypeInternal _Socketpair_default_instance_;

class Tcp6Packet;

struct Tcp6PacketDefaultTypeInternal;

extern Tcp6PacketDefaultTypeInternal _Tcp6Packet_default_instance_;

class TcpHdr;

struct TcpHdrDefaultTypeInternal;

extern TcpHdrDefaultTypeInternal _TcpHdr_default_instance_;

class TcpPacket;

struct TcpPacketDefaultTypeInternal;

extern TcpPacketDefaultTypeInternal _TcpPacket_default_instance_;

PROTOBUF_NAMESPACE_OPEN

template<> ::Accept* Arena::CreateMaybeMessage<::Accept>(Arena*);

template<> ::AcceptNocancel* Arena::CreateMaybeMessage<::AcceptNocancel>(Arena*);

template<> ::Bind* Arena::CreateMaybeMessage<::Bind>(Arena*);

template<> ::ClearAll* Arena::CreateMaybeMessage<::ClearAll>(Arena*);

template<> ::Close* Arena::CreateMaybeMessage<::Close>(Arena*);

template<> ::Command* Arena::CreateMaybeMessage<::Command>(Arena*);

template<> ::Connect* Arena::CreateMaybeMessage<::Connect>(Arena*);

template<> ::ConnectNocancel* Arena::CreateMaybeMessage<::ConnectNocancel>(Arena*);

template<> ::ConnectX* Arena::CreateMaybeMessage<::ConnectX>(Arena*);

template<> ::DisconnectX* Arena::CreateMaybeMessage<::DisconnectX>(Arena*);

template<> ::Endpoints* Arena::CreateMaybeMessage<::Endpoints>(Arena*);

template<> ::GetSocketOpt* Arena::CreateMaybeMessage<::GetSocketOpt>(Arena*);

template<> ::Getpeername* Arena::CreateMaybeMessage<::Getpeername>(Arena*);

template<> ::Getsockname* Arena::CreateMaybeMessage<::Getsockname>(Arena*);

template<> ::IOV* Arena::CreateMaybeMessage<::IOV>(Arena*);

template<> ::Icmp6Hdr* Arena::CreateMaybeMessage<::Icmp6Hdr>(Arena*);

template<> ::IfReqFlags* Arena::CreateMaybeMessage<::IfReqFlags>(Arena*);

template<> ::In6AddrLifetime_64* Arena::CreateMaybeMessage<::In6AddrLifetime_64>(Arena*);

template<> ::In6_AliasReq_64* Arena::CreateMaybeMessage<::In6_AliasReq_64>(Arena*);

template<> ::Ioctl* Arena::CreateMaybeMessage<::Ioctl>(Arena*);

template<> ::IoctlReal* Arena::CreateMaybeMessage<::IoctlReal>(Arena*);

template<> ::Ip4Packet* Arena::CreateMaybeMessage<::Ip4Packet>(Arena*);

template<> ::Ip6Ext* Arena::CreateMaybeMessage<::Ip6Ext>(Arena*);

template<> ::Ip6FragHdr* Arena::CreateMaybeMessage<::Ip6FragHdr>(Arena*);

template<> ::Ip6Hdr* Arena::CreateMaybeMessage<::Ip6Hdr>(Arena*);

template<> ::Ip6Hdrctl* Arena::CreateMaybeMessage<::Ip6Hdrctl>(Arena*);

template<> ::Ip6Packet* Arena::CreateMaybeMessage<::Ip6Packet>(Arena*);

template<> ::Ip6Rt0Hdr* Arena::CreateMaybeMessage<::Ip6Rt0Hdr>(Arena*);

template<> ::Ip6RtHdr* Arena::CreateMaybeMessage<::Ip6RtHdr>(Arena*);

template<> ::IpHdr* Arena::CreateMaybeMessage<::IpHdr>(Arena*);

template<> ::Key* Arena::CreateMaybeMessage<::Key>(Arena*);

template<> ::Listen* Arena::CreateMaybeMessage<::Listen>(Arena*);

template<> ::NecpClientAction* Arena::CreateMaybeMessage<::NecpClientAction>(Arena*);

template<> ::NecpClientActionAdd* Arena::CreateMaybeMessage<::NecpClientActionAdd>(Arena*);

template<> ::NecpClientActionAgent* Arena::CreateMaybeMessage<::NecpClientActionAgent>(Arena*);

template<> ::NecpClientActionCopyParameters* Arena::CreateMaybeMessage<::NecpClientActionCopyParameters>(Arena*);

template<> ::NecpClientActionRemove* Arena::CreateMaybeMessage<::NecpClientActionRemove>(Arena*);

template<> ::NecpMatchPolicy* Arena::CreateMaybeMessage<::NecpMatchPolicy>(Arena*);

template<> ::NecpOpen* Arena::CreateMaybeMessage<::NecpOpen>(Arena*);

template<> ::NecpSessionAction* Arena::CreateMaybeMessage<::NecpSessionAction>(Arena*);

template<> ::NecpSessionOpen* Arena::CreateMaybeMessage<::NecpSessionOpen>(Arena*);

template<> ::NecpTlv* Arena::CreateMaybeMessage<::NecpTlv>(Arena*);

template<> ::Packet* Arena::CreateMaybeMessage<::Packet>(Arena*);

template<> ::Peeloff* Arena::CreateMaybeMessage<::Peeloff>(Arena*);

template<> ::Pipe* Arena::CreateMaybeMessage<::Pipe>(Arena*);

template<> ::Recvfrom* Arena::CreateMaybeMessage<::Recvfrom>(Arena*);

template<> ::RecvfromNocancel* Arena::CreateMaybeMessage<::RecvfromNocancel>(Arena*);

template<> ::Recvmsg* Arena::CreateMaybeMessage<::Recvmsg>(Arena*);

template<> ::Sendmsg* Arena::CreateMaybeMessage<::Sendmsg>(Arena*);

template<> ::Sendto* Arena::CreateMaybeMessage<::Sendto>(Arena*);

template<> ::Session* Arena::CreateMaybeMessage<::Session>(Arena*);

template<> ::SetSocketOpt* Arena::CreateMaybeMessage<::SetSocketOpt>(Arena*);

template<> ::Shutdown* Arena::CreateMaybeMessage<::Shutdown>(Arena*);

template<> ::SockAddr* Arena::CreateMaybeMessage<::SockAddr>(Arena*);

template<> ::SockAddr4* Arena::CreateMaybeMessage<::SockAddr4>(Arena*);

template<> ::SockAddr6* Arena::CreateMaybeMessage<::SockAddr6>(Arena*);

template<> ::SockAddrGeneric* Arena::CreateMaybeMessage<::SockAddrGeneric>(Arena*);

template<> ::Socket* Arena::CreateMaybeMessage<::Socket>(Arena*);

template<> ::Socketpair* Arena::CreateMaybeMessage<::Socketpair>(Arena*);

template<> ::Tcp6Packet* Arena::CreateMaybeMessage<::Tcp6Packet>(Arena*);

template<> ::TcpHdr* Arena::CreateMaybeMessage<::TcpHdr>(Arena*);

template<> ::TcpPacket* Arena::CreateMaybeMessage<::TcpPacket>(Arena*);

PROTOBUF_NAMESPACE_CLOSE

enum SaeAssocID : int {

  ASSOCID_CASE_0 = 0,

  ASSOCID_CASE_1 = 1,

  ASSOCID_CASE_2 = 2,

  ASSOCID_CASE_3 = 3,

  ASSOCID_CASE_END = -1

};

bool SaeAssocID_IsValid(int value);

constexpr SaeAssocID SaeAssocID_MIN = ASSOCID_CASE_END;

constexpr SaeAssocID SaeAssocID_MAX = ASSOCID_CASE_3;

constexpr int SaeAssocID_ARRAYSIZE = SaeAssocID_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SaeAssocID_descriptor();

template<typename T>

inline const std::string& SaeAssocID_Name(T enum_t_value) {

  static_assert(::std::is_same<T, SaeAssocID>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function SaeAssocID_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    SaeAssocID_descriptor(), enum_t_value);

}

inline bool SaeAssocID_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SaeAssocID* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SaeAssocID>(

    SaeAssocID_descriptor(), name, value);

}

enum In6Addr : int {

  IN6_ADDR_ANY = 0,

  IN6_ADDR_LOOPBACK = 1,

  IN6_ADDR_REAL = 2,

  IN6_ADDR_SELF = 3,

  IN6_ADDR_LINK_LOCAL = 4,

  IN6_ADDR_UNSPECIFIED = 5,

  IN6_ADDR_V4COMPAT = 7,

  IN6_ADDR_V4MAPPED = 8,

  IN6_ADDR_6TO4 = 9,

  IN6_ADDR_LINKLOCAL = 10,

  IN6_ADDR_SITELOCAL = 11,

  IN6_ADDR_MULTICAST = 12,

  IN6_ADDR_UNIQUE_LOCAL = 13,

  IN6_ADDR_MC_NODELOCAL = 14,

  IN6_ADDR_MC_INTFACELOCAL = 15,

  IN6_ADDR_MC_LINKLOCAL = 16,

  IN6_ADDR_MC_SITELOCAL = 17,

  IN6_ADDR_MC_ORGLOCAL = 18,

  IN6_ADDR_MC_GLOBAL = 19,

  IN6_ADDR_LOCAL_ADDRESS = 20,

  MAYBE_LOCALHOST = 16777216

};

bool In6Addr_IsValid(int value);

constexpr In6Addr In6Addr_MIN = IN6_ADDR_ANY;

constexpr In6Addr In6Addr_MAX = MAYBE_LOCALHOST;

constexpr int In6Addr_ARRAYSIZE = In6Addr_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* In6Addr_descriptor();

template<typename T>

inline const std::string& In6Addr_Name(T enum_t_value) {

  static_assert(::std::is_same<T, In6Addr>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function In6Addr_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    In6Addr_descriptor(), enum_t_value);

}

inline bool In6Addr_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, In6Addr* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<In6Addr>(

    In6Addr_descriptor(), name, value);

}

enum InAddr : int {

  IN4_ADDR_0 = 0,

  IN4_ADDR_1 = 1,

  IN4_ADDR_2 = 2,

  IN4_ADDR_4 = 411187920,

  IN4_ADDR_5 = 2130706433,

  IN4_ADDR_6 = -1062709672,

  IN4_ADDR_BROADCAST = -1

};

bool InAddr_IsValid(int value);

constexpr InAddr InAddr_MIN = IN4_ADDR_6;

constexpr InAddr InAddr_MAX = IN4_ADDR_5;

constexpr int InAddr_ARRAYSIZE = InAddr_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* InAddr_descriptor();

template<typename T>

inline const std::string& InAddr_Name(T enum_t_value) {

  static_assert(::std::is_same<T, InAddr>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function InAddr_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    InAddr_descriptor(), enum_t_value);

}

inline bool InAddr_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InAddr* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<InAddr>(

    InAddr_descriptor(), name, value);

}

enum FlowInfo : int {

  FLOW_INFO_0 = 0,

  FLOW_INFO_1 = 1,

  FLOW_INFO_2 = 2,

  FLOW_INFO_3 = 3

};

bool FlowInfo_IsValid(int value);

constexpr FlowInfo FlowInfo_MIN = FLOW_INFO_0;

constexpr FlowInfo FlowInfo_MAX = FLOW_INFO_3;

constexpr int FlowInfo_ARRAYSIZE = FlowInfo_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FlowInfo_descriptor();

template<typename T>

inline const std::string& FlowInfo_Name(T enum_t_value) {

  static_assert(::std::is_same<T, FlowInfo>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function FlowInfo_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    FlowInfo_descriptor(), enum_t_value);

}

inline bool FlowInfo_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FlowInfo* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FlowInfo>(

    FlowInfo_descriptor(), name, value);

}

enum ScopeId : int {

  SCOPE_ID_0 = 0,

  SCOPE_ID_1 = 1,

  SCOPE_ID_2 = 2,

  SCOPE_ID_3 = 3,

  SCOPE_ID_50 = 50

};

bool ScopeId_IsValid(int value);

constexpr ScopeId ScopeId_MIN = SCOPE_ID_0;

constexpr ScopeId ScopeId_MAX = SCOPE_ID_50;

constexpr int ScopeId_ARRAYSIZE = ScopeId_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ScopeId_descriptor();

template<typename T>

inline const std::string& ScopeId_Name(T enum_t_value) {

  static_assert(::std::is_same<T, ScopeId>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function ScopeId_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    ScopeId_descriptor(), enum_t_value);

}

inline bool ScopeId_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ScopeId* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ScopeId>(

    ScopeId_descriptor(), name, value);

}

enum Port : int {

  PORT_0 = 0,

  PORT_1 = 1,

  PORT_2 = 2,

  PORT_5555 = 5555,

  PORT_65000 = 65000

};

bool Port_IsValid(int value);

constexpr Port Port_MIN = PORT_0;

constexpr Port Port_MAX = PORT_65000;

constexpr int Port_ARRAYSIZE = Port_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Port_descriptor();

template<typename T>

inline const std::string& Port_Name(T enum_t_value) {

  static_assert(::std::is_same<T, Port>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function Port_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    Port_descriptor(), enum_t_value);

}

inline bool Port_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Port* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Port>(

    Port_descriptor(), name, value);

}

enum IfIdx : int {

  IFIDX_CASE_0 = 0,

  IFIDX_CASE_1 = 1,

  IFIDX_CASE_2 = 2,

  IFIDX_CASE_3 = 3

};

bool IfIdx_IsValid(int value);

constexpr IfIdx IfIdx_MIN = IFIDX_CASE_0;

constexpr IfIdx IfIdx_MAX = IFIDX_CASE_3;

constexpr int IfIdx_ARRAYSIZE = IfIdx_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IfIdx_descriptor();

template<typename T>

inline const std::string& IfIdx_Name(T enum_t_value) {

  static_assert(::std::is_same<T, IfIdx>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function IfIdx_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    IfIdx_descriptor(), enum_t_value);

}

inline bool IfIdx_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IfIdx* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<IfIdx>(

    IfIdx_descriptor(), name, value);

}

enum ConnectXFlag : int {

  CONNECT_RESUME_ON_READ_WRITE = 1,

  CONNECT_DATA_IDEMPOTENT = 2,

  CONNECT_DATA_AUTHENTICATED = 4

};

bool ConnectXFlag_IsValid(int value);

constexpr ConnectXFlag ConnectXFlag_MIN = CONNECT_RESUME_ON_READ_WRITE;

constexpr ConnectXFlag ConnectXFlag_MAX = CONNECT_DATA_AUTHENTICATED;

constexpr int ConnectXFlag_ARRAYSIZE = ConnectXFlag_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConnectXFlag_descriptor();

template<typename T>

inline const std::string& ConnectXFlag_Name(T enum_t_value) {

  static_assert(::std::is_same<T, ConnectXFlag>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function ConnectXFlag_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    ConnectXFlag_descriptor(), enum_t_value);

}

inline bool ConnectXFlag_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectXFlag* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ConnectXFlag>(

    ConnectXFlag_descriptor(), name, value);

}

enum ShutdownHow : int {

  SHUT_RD = 0,

  SHUT_WR = 1,

  SHUT_RDWR = 2

};

bool ShutdownHow_IsValid(int value);

constexpr ShutdownHow ShutdownHow_MIN = SHUT_RD;

constexpr ShutdownHow ShutdownHow_MAX = SHUT_RDWR;

constexpr int ShutdownHow_ARRAYSIZE = ShutdownHow_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ShutdownHow_descriptor();

template<typename T>

inline const std::string& ShutdownHow_Name(T enum_t_value) {

  static_assert(::std::is_same<T, ShutdownHow>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function ShutdownHow_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    ShutdownHow_descriptor(), enum_t_value);

}

inline bool ShutdownHow_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ShutdownHow* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ShutdownHow>(

    ShutdownHow_descriptor(), name, value);

}

enum NecpOpenFlag : int {

  NECP_OPEN_FLAG_OBSERVER = 1,

  NECP_OPEN_FLAG_BACKGROUND = 2,

  NECP_OPEN_FLAG_PUSH_OBSERVER = 4

};

bool NecpOpenFlag_IsValid(int value);

constexpr NecpOpenFlag NecpOpenFlag_MIN = NECP_OPEN_FLAG_OBSERVER;

constexpr NecpOpenFlag NecpOpenFlag_MAX = NECP_OPEN_FLAG_PUSH_OBSERVER;

constexpr int NecpOpenFlag_ARRAYSIZE = NecpOpenFlag_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NecpOpenFlag_descriptor();

template<typename T>

inline const std::string& NecpOpenFlag_Name(T enum_t_value) {

  static_assert(::std::is_same<T, NecpOpenFlag>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function NecpOpenFlag_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    NecpOpenFlag_descriptor(), enum_t_value);

}

inline bool NecpOpenFlag_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NecpOpenFlag* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NecpOpenFlag>(

    NecpOpenFlag_descriptor(), name, value);

}

enum NecpClientId : int {

  CLIENT_0 = 0,

  CLIENT_1 = 1,

  CLIENT_2 = 2

};

bool NecpClientId_IsValid(int value);

constexpr NecpClientId NecpClientId_MIN = CLIENT_0;

constexpr NecpClientId NecpClientId_MAX = CLIENT_2;

constexpr int NecpClientId_ARRAYSIZE = NecpClientId_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NecpClientId_descriptor();

template<typename T>

inline const std::string& NecpClientId_Name(T enum_t_value) {

  static_assert(::std::is_same<T, NecpClientId>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function NecpClientId_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    NecpClientId_descriptor(), enum_t_value);

}

inline bool NecpClientId_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NecpClientId* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NecpClientId>(

    NecpClientId_descriptor(), name, value);

}

enum NecpClientActionNumber : int {

  NECP_CLIENT_ACTION_ADD = 1,

  NECP_CLIENT_ACTION_REMOVE = 2,

  NECP_CLIENT_ACTION_COPY_PARAMETERS = 3,

  NECP_CLIENT_ACTION_COPY_RESULT = 4,

  NECP_CLIENT_ACTION_COPY_LIST = 5,

  NECP_CLIENT_ACTION_REQUEST_NEXUS_INSTANCE = 6,

  NECP_CLIENT_ACTION_AGENT = 7,

  NECP_CLIENT_ACTION_COPY_AGENT = 8,

  NECP_CLIENT_ACTION_COPY_INTERFACE = 9,

  NECP_CLIENT_ACTION_SET_STATISTICS = 10,

  NECP_CLIENT_ACTION_COPY_ROUTE_STATISTICS = 11,

  NECP_CLIENT_ACTION_AGENT_USE = 12,

  NECP_CLIENT_ACTION_MAP_SYSCTLS = 13,

  NECP_CLIENT_ACTION_UPDATE_CACHE = 14,

  NECP_CLIENT_ACTION_COPY_CLIENT_UPDATE = 15,

  NECP_CLIENT_ACTION_COPY_UPDATED_RESULT = 16,

  NECP_CLIENT_ACTION_ADD_FLOW = 17,

  NECP_CLIENT_ACTION_REMOVE_FLOW = 18

};

bool NecpClientActionNumber_IsValid(int value);

constexpr NecpClientActionNumber NecpClientActionNumber_MIN = NECP_CLIENT_ACTION_ADD;

constexpr NecpClientActionNumber NecpClientActionNumber_MAX = NECP_CLIENT_ACTION_REMOVE_FLOW;

constexpr int NecpClientActionNumber_ARRAYSIZE = NecpClientActionNumber_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NecpClientActionNumber_descriptor();

template<typename T>

inline const std::string& NecpClientActionNumber_Name(T enum_t_value) {

  static_assert(::std::is_same<T, NecpClientActionNumber>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function NecpClientActionNumber_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    NecpClientActionNumber_descriptor(), enum_t_value);

}

inline bool NecpClientActionNumber_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NecpClientActionNumber* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NecpClientActionNumber>(

    NecpClientActionNumber_descriptor(), name, value);

}

enum NecpSessionActionNumber : int {

  NECP_SESSION_ACTION_POLICY_ADD = 1,

  NECP_SESSION_ACTION_POLICY_GET = 2,

  NECP_SESSION_ACTION_POLICY_DELETE = 3,

  NECP_SESSION_ACTION_POLICY_APPLY_ALL = 4,

  NECP_SESSION_ACTION_POLICY_LIST_ALL = 5,

  NECP_SESSION_ACTION_POLICY_DELETE_ALL = 6,

  NECP_SESSION_ACTION_SET_SESSION_PRIORITY = 7,

  NECP_SESSION_ACTION_LOCK_SESSION_TO_PROC = 8,

  NECP_SESSION_ACTION_REGISTER_SERVICE = 9,

  NECP_SESSION_ACTION_UNREGISTER_SERVICE = 10,

  NECP_SESSION_ACTION_POLICY_DUMP_ALL = 11

};

bool NecpSessionActionNumber_IsValid(int value);

constexpr NecpSessionActionNumber NecpSessionActionNumber_MIN = NECP_SESSION_ACTION_POLICY_ADD;

constexpr NecpSessionActionNumber NecpSessionActionNumber_MAX = NECP_SESSION_ACTION_POLICY_DUMP_ALL;

constexpr int NecpSessionActionNumber_ARRAYSIZE = NecpSessionActionNumber_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NecpSessionActionNumber_descriptor();

template<typename T>

inline const std::string& NecpSessionActionNumber_Name(T enum_t_value) {

  static_assert(::std::is_same<T, NecpSessionActionNumber>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function NecpSessionActionNumber_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    NecpSessionActionNumber_descriptor(), enum_t_value);

}

inline bool NecpSessionActionNumber_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NecpSessionActionNumber* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NecpSessionActionNumber>(

    NecpSessionActionNumber_descriptor(), name, value);

}

enum IfrName : int {

  LO0 = 0,

  STF0 = 1

};

bool IfrName_IsValid(int value);

constexpr IfrName IfrName_MIN = LO0;

constexpr IfrName IfrName_MAX = STF0;

constexpr int IfrName_ARRAYSIZE = IfrName_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IfrName_descriptor();

template<typename T>

inline const std::string& IfrName_Name(T enum_t_value) {

  static_assert(::std::is_same<T, IfrName>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function IfrName_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    IfrName_descriptor(), enum_t_value);

}

inline bool IfrName_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IfrName* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<IfrName>(

    IfrName_descriptor(), name, value);

}

enum IfruFlag : int {

  IFF_UP = 1,

  IFF_BROADCAST = 2,

  IFF_DEBUG = 4,

  IFF_LOOPBACK = 8,

  IFF_POINTOPOINT = 16,

  IFF_NOTRAILERS = 32,

  IFF_RUNNING = 64,

  IFF_NOARP = 128,

  IFF_PROMISC = 256,

  IFF_ALLMULTI = 512,

  IFF_OACTIVE = 1024,

  IFF_SIMPLEX = 2048,

  IFF_LINK0 = 4096,

  IFF_LINK1 = 8192,

  IFF_LINK2 = 16384,

  IFF_MULTICAST = 32768

};

bool IfruFlag_IsValid(int value);

constexpr IfruFlag IfruFlag_MIN = IFF_UP;

constexpr IfruFlag IfruFlag_MAX = IFF_MULTICAST;

constexpr int IfruFlag_ARRAYSIZE = IfruFlag_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IfruFlag_descriptor();

template<typename T>

inline const std::string& IfruFlag_Name(T enum_t_value) {

  static_assert(::std::is_same<T, IfruFlag>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function IfruFlag_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    IfruFlag_descriptor(), enum_t_value);

}

inline bool IfruFlag_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IfruFlag* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<IfruFlag>(

    IfruFlag_descriptor(), name, value);

}

enum IfraFlag : int {

  IN6_IFF_ANYCAST = 1,

  IN6_IFF_TENTATIVE = 2,

  IN6_IFF_DUPLICATED = 4,

  IN6_IFF_DETACHED = 8,

  IN6_IFF_DEPRECATED = 16,

  IN6_IFF_NODAD = 32,

  IN6_IFF_AUTOCONF = 64,

  IN6_IFF_TEMPORARY = 128,

  IN6_IFF_DYNAMIC = 256,

  IN6_IFF_OPTIMISTIC = 512,

  IN6_IFF_SECURED = 1024,

  IN6_IFF_SWIFTDAD = 2048,

  IN6_IFF_CLAT46 = 4096,

  IN6_IFF_NOPFX = 32768

};

bool IfraFlag_IsValid(int value);

constexpr IfraFlag IfraFlag_MIN = IN6_IFF_ANYCAST;

constexpr IfraFlag IfraFlag_MAX = IN6_IFF_NOPFX;

constexpr int IfraFlag_ARRAYSIZE = IfraFlag_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IfraFlag_descriptor();

template<typename T>

inline const std::string& IfraFlag_Name(T enum_t_value) {

  static_assert(::std::is_same<T, IfraFlag>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function IfraFlag_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    IfraFlag_descriptor(), enum_t_value);

}

inline bool IfraFlag_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IfraFlag* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<IfraFlag>(

    IfraFlag_descriptor(), name, value);

}

enum Ip6RtType : int {

  IPV6_RTHDR_TYPE_0 = 0

};

bool Ip6RtType_IsValid(int value);

constexpr Ip6RtType Ip6RtType_MIN = IPV6_RTHDR_TYPE_0;

constexpr Ip6RtType Ip6RtType_MAX = IPV6_RTHDR_TYPE_0;

constexpr int Ip6RtType_ARRAYSIZE = Ip6RtType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Ip6RtType_descriptor();

template<typename T>

inline const std::string& Ip6RtType_Name(T enum_t_value) {

  static_assert(::std::is_same<T, Ip6RtType>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function Ip6RtType_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    Ip6RtType_descriptor(), enum_t_value);

}

inline bool Ip6RtType_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Ip6RtType* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Ip6RtType>(

    Ip6RtType_descriptor(), name, value);

}

enum Icmp6Type : int {

  ICMP6_DST_UNREACH = 1,

  ICMP6_PACKET_TOO_BIG = 2,

  ICMP6_TIME_EXCEEDED = 3,

  ICMP6_PARAM_PROB = 4,

  ICMP6_ECHO_REQUEST = 128,

  ICMP6_ECHO_REPLY = 129,

  MLD_LISTENER_QUERY = 130,

  MLD_LISTENER_REPORT = 131,

  MLD_LISTENER_DONE = 132,

  ND_ROUTER_SOLICIT = 133,

  ND_ROUTER_ADVERT = 134,

  ND_NEIGHBOR_SOLICIT = 135,

  ND_NEIGHBOR_ADVERT = 136,

  ND_REDIRECT = 137,

  ICMP6_ROUTER_RENUMBERING = 138,

  ICMP6_WRUREQUEST = 139,

  ICMP6_WRUREPLY = 140,

  MLDV2_LISTENER_REPORT = 143,

  MLD_MTRACE_RESP = 200,

  MLD_MTRACE = 201

};

bool Icmp6Type_IsValid(int value);

constexpr Icmp6Type Icmp6Type_MIN = ICMP6_DST_UNREACH;

constexpr Icmp6Type Icmp6Type_MAX = MLD_MTRACE;

constexpr int Icmp6Type_ARRAYSIZE = Icmp6Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Icmp6Type_descriptor();

template<typename T>

inline const std::string& Icmp6Type_Name(T enum_t_value) {

  static_assert(::std::is_same<T, Icmp6Type>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function Icmp6Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    Icmp6Type_descriptor(), enum_t_value);

}

inline bool Icmp6Type_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Icmp6Type* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Icmp6Type>(

    Icmp6Type_descriptor(), name, value);

}

enum Icmp6Code : int {

  ICMP6_DST_UNREACH_NOROUTE = 0,

  ICMP6_DST_UNREACH_ADMIN = 1,

  ICMP6_DST_UNREACH_NOTNEIGHBOR = 2,

  ICMP6_DST_UNREACH_ADDR = 3,

  ICMP6_DST_UNREACH_NOPORT = 4,

  ICMP6_INFOMSG_MASK = 128,

  ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET = 255

};

bool Icmp6Code_IsValid(int value);

constexpr Icmp6Code Icmp6Code_MIN = ICMP6_DST_UNREACH_NOROUTE;

constexpr Icmp6Code Icmp6Code_MAX = ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET;

constexpr int Icmp6Code_ARRAYSIZE = Icmp6Code_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Icmp6Code_descriptor();

template<typename T>

inline const std::string& Icmp6Code_Name(T enum_t_value) {

  static_assert(::std::is_same<T, Icmp6Code>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function Icmp6Code_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    Icmp6Code_descriptor(), enum_t_value);

}

inline bool Icmp6Code_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Icmp6Code* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Icmp6Code>(

    Icmp6Code_descriptor(), name, value);

}

enum TcpSeq : int {

  SEQ_1 = 1,

  SEQ_2 = 2,

  SEQ_3 = 3,

  SEQ_4 = 4,

  SEQ_5 = 5,

  SEQ_6 = 6,

  SEQ_7 = 7,

  SEQ_8 = 8

};

bool TcpSeq_IsValid(int value);

constexpr TcpSeq TcpSeq_MIN = SEQ_1;

constexpr TcpSeq TcpSeq_MAX = SEQ_8;

constexpr int TcpSeq_ARRAYSIZE = TcpSeq_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TcpSeq_descriptor();

template<typename T>

inline const std::string& TcpSeq_Name(T enum_t_value) {

  static_assert(::std::is_same<T, TcpSeq>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function TcpSeq_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    TcpSeq_descriptor(), enum_t_value);

}

inline bool TcpSeq_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TcpSeq* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TcpSeq>(

    TcpSeq_descriptor(), name, value);

}

enum TcpFlag : int {

  TH_FIN = 1,

  TH_SYN = 2,

  TH_RST = 4,

  TH_PUSH = 8,

  TH_ACK = 16,

  TH_URG = 32,

  TH_ECE = 64,

  TH_CWR = 128

};

bool TcpFlag_IsValid(int value);

constexpr TcpFlag TcpFlag_MIN = TH_FIN;

constexpr TcpFlag TcpFlag_MAX = TH_CWR;

constexpr int TcpFlag_ARRAYSIZE = TcpFlag_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TcpFlag_descriptor();

template<typename T>

inline const std::string& TcpFlag_Name(T enum_t_value) {

  static_assert(::std::is_same<T, TcpFlag>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function TcpFlag_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    TcpFlag_descriptor(), enum_t_value);

}

inline bool TcpFlag_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TcpFlag* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TcpFlag>(

    TcpFlag_descriptor(), name, value);

}

enum IpVersion : int {

  IPV4 = 4,

  IPV6 = 6

};

bool IpVersion_IsValid(int value);

constexpr IpVersion IpVersion_MIN = IPV4;

constexpr IpVersion IpVersion_MAX = IPV6;

constexpr int IpVersion_ARRAYSIZE = IpVersion_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IpVersion_descriptor();

template<typename T>

inline const std::string& IpVersion_Name(T enum_t_value) {

  static_assert(::std::is_same<T, IpVersion>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function IpVersion_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    IpVersion_descriptor(), enum_t_value);

}

inline bool IpVersion_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IpVersion* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<IpVersion>(

    IpVersion_descriptor(), name, value);

}

enum IoctlIdx : int {

  SIOCSHIWAT = 1,

  SIOCGHIWAT = 2,

  SIOCSLOWAT = 3,

  SIOCGLOWAT = 4,

  SIOCATMARK = 5,

  SIOCSPGRP = 6,

  SIOCGPGRP = 7,

  SIOCSIFADDR = 8,

  OSIOCGIFADDR = 9,

  SIOCSIFDSTADDR = 10,

  OSIOCGIFDSTADDR = 11,

  SIOCSIFFLAGS = 12,

  SIOCGIFFLAGS = 13,

  OSIOCGIFBRDADDR = 14,

  SIOCSIFBRDADDR = 15,

  OSIOCGIFCONF = 16,

  OSIOCGIFCONF32 = 17,

  OSIOCGIFCONF64 = 18,

  OSIOCGIFNETMASK = 19,

  SIOCSIFNETMASK = 20,

  SIOCGIFMETRIC = 21,

  SIOCSIFMETRIC = 22,

  SIOCDIFADDR = 23,

  SIOCAIFADDR = 24,

  SIOCGIFADDR = 25,

  SIOCGIFDSTADDR = 26,

  SIOCGIFBRDADDR = 27,

  SIOCGIFCONF = 28,

  SIOCGIFCONF32 = 29,

  SIOCGIFCONF64 = 30,

  SIOCGIFNETMASK = 31,

  SIOCADDMULTI = 32,

  SIOCDELMULTI = 33,

  SIOCGIFMTU = 34,

  SIOCSIFMTU = 35,

  SIOCGIFPHYS = 36,

  SIOCSIFPHYS = 37,

  SIOCSIFMEDIA = 38,

  SIOCGIFMEDIA = 39,

  SIOCGIFMEDIA32 = 40,

  SIOCGIFMEDIA64 = 41,

  SIOCSIFGENERIC = 42,

  SIOCGIFGENERIC = 43,

  SIOCSIFLLADDR = 44,

  SIOCGIFSTATUS = 45,

  SIOCSIFPHYADDR = 46,

  SIOCGIFPSRCADDR = 47,

  SIOCGIFPDSTADDR = 48,

  SIOCDIFPHYADDR = 49,

  SIOCGIFDEVMTU = 50,

  SIOCSIFALTMTU = 51,

  SIOCPROTOATTACH = 52,

  SIOCPROTODETACH = 53,

  SIOCIFCREATE = 54,

  SIOCIFDESTROY = 55,

  SIOCSIFVLAN = 56,

  SIOCGIFVLAN = 57,

  SIOCSETVLAN = 58,

  SIOCGETVLAN = 59,

  SIOCSIFDEVMTU = 60,

  SIOCIFGCLONERS = 61,

  SIOCIFGCLONERS32 = 62,

  SIOCIFGCLONERS64 = 63,

  SIOCGIFASYNCMAP = 64,

  SIOCSIFASYNCMAP = 65,

  SIOCSIFKPI = 66,

  SIOCGIFKPI = 67,

  SIOCGIFWAKEFLAGS = 68,

  SIOCGIFGETRTREFCNT = 69,

  SIOCGIFLINKQUALITYMETRIC = 70,

  SIOCSETROUTERMODE = 71,

  SIOCGIFEFLAGS = 72,

  SIOCSIFDESC = 73,

  SIOCGIFDESC = 74,

  SIOCSIFLINKPARAMS = 75,

  SIOCGIFLINKPARAMS = 76,

  SIOCGIFQUEUESTATS = 77,

  SIOCSIFTHROTTLE = 78,

  SIOCGIFTHROTTLE = 79,

  SIOCGASSOCIDS = 80,

  SIOCGCONNIDS = 81,

  SIOCGCONNINFO = 82,

  SIOCGASSOCIDS32 = 83,

  SIOCGASSOCIDS64 = 84,

  SIOCGCONNIDS32 = 85,

  SIOCGCONNIDS64 = 86,

  SIOCGCONNINFO32 = 87,

  SIOCGCONNINFO64 = 88,

  SIOCSCONNORDER = 89,

  SIOCGCONNORDER = 90,

  SIOCSIFLOG = 91,

  SIOCGIFLOG = 92,

  SIOCGIFDELEGATE = 93,

  SIOCGIFLLADDR = 94,

  SIOCGIFTYPE = 95,

  SIOCGIFEXPENSIVE = 96,

  SIOCSIFEXPENSIVE = 97,

  SIOCGIF2KCL = 98,

  SIOCSIF2KCL = 99,

  SIOCGSTARTDELAY = 100,

  SIOCAIFAGENTID = 101,

  SIOCDIFAGENTID = 102,

  SIOCGIFAGENTIDS = 103,

  SIOCGIFAGENTDATA = 104,

  SIOCGIFAGENTIDS32 = 105,

  SIOCGIFAGENTIDS64 = 106,

  SIOCGIFAGENTDATA32 = 107,

  SIOCGIFAGENTDATA64 = 108,

  SIOCSIFINTERFACESTATE = 109,

  SIOCGIFINTERFACESTATE = 110,

  SIOCSIFPROBECONNECTIVITY = 111,

  SIOCGIFPROBECONNECTIVITY = 112,

  SIOCGIFFUNCTIONALTYPE = 113,

  SIOCSIFNETSIGNATURE = 114,

  SIOCGIFNETSIGNATURE = 115,

  SIOCGECNMODE = 116,

  SIOCSECNMODE = 117,

  SIOCSIFORDER = 118,

  SIOCGIFORDER = 119,

  SIOCSQOSMARKINGMODE = 120,

  SIOCSFASTLANECAPABLE = 121,

  SIOCSQOSMARKINGENABLED = 122,

  SIOCSFASTLEENABLED = 123,

  SIOCGQOSMARKINGMODE = 124,

  SIOCGQOSMARKINGENABLED = 125,

  SIOCSIFTIMESTAMPENABLE = 126,

  SIOCSIFTIMESTAMPDISABLE = 127,

  SIOCGIFTIMESTAMPENABLED = 128,

  SIOCSIFDISABLEOUTPUT = 129,

  SIOCGIFAGENTLIST = 130,

  SIOCGIFAGENTLIST32 = 131,

  SIOCGIFAGENTLIST64 = 132,

  SIOCSIFLOWINTERNET = 133,

  SIOCGIFLOWINTERNET = 134,

  SIOCGIFNAT64PREFIX = 135,

  SIOCSIFNAT64PREFIX = 136,

  SIOCGIFNEXUS = 137,

  SIOCSIFADDR_IN6 = 138,

  SIOCGIFADDR_IN6 = 139,

  SIOCSIFDSTADDR_IN6 = 140,

  SIOCSIFNETMASK_IN6 = 141,

  SIOCGIFDSTADDR_IN6 = 142,

  SIOCGIFNETMASK_IN6 = 143,

  SIOCDIFADDR_IN6 = 144,

  SIOCAIFADDR_IN6 = 145,

  SIOCAIFADDR_IN6_32 = 146,

  SIOCAIFADDR_IN6_64 = 147,

  SIOCSIFPHYADDR_IN6 = 148,

  SIOCSIFPHYADDR_IN6_32 = 149,

  SIOCSIFPHYADDR_IN6_64 = 150,

  SIOCGIFPSRCADDR_IN6 = 151,

  SIOCGIFPDSTADDR_IN6 = 152,

  SIOCGIFAFLAG_IN6 = 153,

  SIOCGDRLST_IN6 = 154,

  SIOCGDRLST_IN6_32 = 155,

  SIOCGDRLST_IN6_64 = 156,

  SIOCGPRLST_IN6 = 157,

  SIOCGPRLST_IN6_32 = 158,

  SIOCGPRLST_IN6_64 = 159,

  OSIOCGIFINFO_IN6 = 160,

  SIOCGIFINFO_IN6 = 161,

  SIOCSNDFLUSH_IN6 = 162,

  SIOCGNBRINFO_IN6 = 163,

  SIOCGNBRINFO_IN6_32 = 164,

  SIOCGNBRINFO_IN6_64 = 165,

  SIOCSPFXFLUSH_IN6 = 166,

  SIOCSRTRFLUSH_IN6 = 167,

  SIOCGIFALIFETIME_IN6 = 168,

  SIOCSIFALIFETIME_IN6 = 169,

  SIOCGIFSTAT_IN6 = 170,

  SIOCGIFSTAT_ICMP6 = 171,

  SIOCSDEFIFACE_IN6 = 172,

  SIOCGDEFIFACE_IN6 = 173,

  SIOCSDEFIFACE_IN6_32 = 174,