/src/build/net_fuzzer.pb.cc

Source (jump to first uncovered line)
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: net_fuzzer.proto

#include "net_fuzzer.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
constexpr Session::Session(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : commands_()
  , data_provider_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct SessionDefaultTypeInternal {
  constexpr SessionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SessionDefaultTypeInternal() {}
  union {
    Session _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SessionDefaultTypeInternal _Session_default_instance_;
constexpr Connect::Connect(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : sockaddr_(nullptr)
  , fd_(0)
{}
struct ConnectDefaultTypeInternal {
  constexpr ConnectDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ConnectDefaultTypeInternal() {}
  union {
    Connect _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectDefaultTypeInternal _Connect_default_instance_;
constexpr ConnectX::ConnectX(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : flags_()
  , endpoints_(nullptr)
  , socket_(0)

  , associd_(0)
{}
struct ConnectXDefaultTypeInternal {
  constexpr ConnectXDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ConnectXDefaultTypeInternal() {}
  union {
    ConnectX _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectXDefaultTypeInternal _ConnectX_default_instance_;
constexpr DisconnectX::DisconnectX(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : associd_(0)

  , cid_(0)
  , fd_(0)
{}
struct DisconnectXDefaultTypeInternal {
  constexpr DisconnectXDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DisconnectXDefaultTypeInternal() {}
  union {
    DisconnectX _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DisconnectXDefaultTypeInternal _DisconnectX_default_instance_;
constexpr IOV::IOV(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : iov_data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct IOVDefaultTypeInternal {
  constexpr IOVDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~IOVDefaultTypeInternal() {}
  union {
    IOV _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT IOVDefaultTypeInternal _IOV_default_instance_;
constexpr Endpoints::Endpoints(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : sae_srcaddr_(nullptr)
  , sae_dstaddr_(nullptr)
  , sae_srcif_(0)
{}
struct EndpointsDefaultTypeInternal {
  constexpr EndpointsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~EndpointsDefaultTypeInternal() {}
  union {
    Endpoints _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT EndpointsDefaultTypeInternal _Endpoints_default_instance_;
constexpr SockAddr::SockAddr(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct SockAddrDefaultTypeInternal {
  constexpr SockAddrDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SockAddrDefaultTypeInternal() {}
  union {
    SockAddr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SockAddrDefaultTypeInternal _SockAddr_default_instance_;
constexpr SockAddrGeneric::SockAddrGeneric(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : sa_data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , sa_family_(0)
{}
struct SockAddrGenericDefaultTypeInternal {
  constexpr SockAddrGenericDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SockAddrGenericDefaultTypeInternal() {}
  union {
    SockAddrGeneric _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SockAddrGenericDefaultTypeInternal _SockAddrGeneric_default_instance_;
constexpr SockAddr4::SockAddr4(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : sin_family_(0)

  , sin_port_(0)

  , sin_addr_(0)
{}
struct SockAddr4DefaultTypeInternal {
  constexpr SockAddr4DefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SockAddr4DefaultTypeInternal() {}
  union {
    SockAddr4 _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SockAddr4DefaultTypeInternal _SockAddr4_default_instance_;
constexpr SockAddr6::SockAddr6(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : family_(0)

  , port_(0)

  , flow_info_(0)

  , sin6_addr_(0)

  , sin6_scope_id_(0)
{}
struct SockAddr6DefaultTypeInternal {
  constexpr SockAddr6DefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SockAddr6DefaultTypeInternal() {}
  union {
    SockAddr6 _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SockAddr6DefaultTypeInternal _SockAddr6_default_instance_;
constexpr Command::Command(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct CommandDefaultTypeInternal {
  constexpr CommandDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CommandDefaultTypeInternal() {}
  union {
    Command _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CommandDefaultTypeInternal _Command_default_instance_;
constexpr AcceptNocancel::AcceptNocancel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : name_(nullptr)
  , s_(0)
{}
struct AcceptNocancelDefaultTypeInternal {
  constexpr AcceptNocancelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AcceptNocancelDefaultTypeInternal() {}
  union {
    AcceptNocancel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AcceptNocancelDefaultTypeInternal _AcceptNocancel_default_instance_;
constexpr ConnectNocancel::ConnectNocancel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : name_(nullptr)
  , s_(0)
{}
struct ConnectNocancelDefaultTypeInternal {
  constexpr ConnectNocancelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ConnectNocancelDefaultTypeInternal() {}
  union {
    ConnectNocancel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectNocancelDefaultTypeInternal _ConnectNocancel_default_instance_;
constexpr Getpeername::Getpeername(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : asa_(nullptr)
  , fdes_(0)
{}
struct GetpeernameDefaultTypeInternal {
  constexpr GetpeernameDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~GetpeernameDefaultTypeInternal() {}
  union {
    Getpeername _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetpeernameDefaultTypeInternal _Getpeername_default_instance_;
constexpr Getsockname::Getsockname(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : asa_(nullptr)
  , fdes_(0)
{}
struct GetsocknameDefaultTypeInternal {
  constexpr GetsocknameDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~GetsocknameDefaultTypeInternal() {}
  union {
    Getsockname _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetsocknameDefaultTypeInternal _Getsockname_default_instance_;
constexpr Peeloff::Peeloff(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : s_(0)

  , aid_(0)
{}
struct PeeloffDefaultTypeInternal {
  constexpr PeeloffDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~PeeloffDefaultTypeInternal() {}
  union {
    Peeloff _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PeeloffDefaultTypeInternal _Peeloff_default_instance_;
constexpr Pipe::Pipe(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct PipeDefaultTypeInternal {
  constexpr PipeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~PipeDefaultTypeInternal() {}
  union {
    Pipe _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PipeDefaultTypeInternal _Pipe_default_instance_;
constexpr Shutdown::Shutdown(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : s_(0)

  , how_(0)
{}
struct ShutdownDefaultTypeInternal {
  constexpr ShutdownDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ShutdownDefaultTypeInternal() {}
  union {
    Shutdown _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ShutdownDefaultTypeInternal _Shutdown_default_instance_;
constexpr Recvfrom::Recvfrom(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : buf_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , from_(nullptr)
  , s_(0)

  , flags_(0){}
struct RecvfromDefaultTypeInternal {
  constexpr RecvfromDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RecvfromDefaultTypeInternal() {}
  union {
    Recvfrom _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RecvfromDefaultTypeInternal _Recvfrom_default_instance_;
constexpr RecvfromNocancel::RecvfromNocancel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : buf_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , from_(nullptr)
  , s_(0)

  , flags_(0){}
struct RecvfromNocancelDefaultTypeInternal {
  constexpr RecvfromNocancelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RecvfromNocancelDefaultTypeInternal() {}
  union {
    RecvfromNocancel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RecvfromNocancelDefaultTypeInternal _RecvfromNocancel_default_instance_;
constexpr Recvmsg::Recvmsg(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : s_(0)

  , flags_(0u){}
struct RecvmsgDefaultTypeInternal {
  constexpr RecvmsgDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RecvmsgDefaultTypeInternal() {}
  union {
    Recvmsg _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RecvmsgDefaultTypeInternal _Recvmsg_default_instance_;
constexpr Sendmsg::Sendmsg(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : msg_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , s_(0)

  , flags_(0u){}
struct SendmsgDefaultTypeInternal {
  constexpr SendmsgDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SendmsgDefaultTypeInternal() {}
  union {
    Sendmsg _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SendmsgDefaultTypeInternal _Sendmsg_default_instance_;
constexpr Sendto::Sendto(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : buf_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , to_(nullptr)
  , s_(0)

  , flags_(0){}
struct SendtoDefaultTypeInternal {
  constexpr SendtoDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SendtoDefaultTypeInternal() {}
  union {
    Sendto _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SendtoDefaultTypeInternal _Sendto_default_instance_;
constexpr Socketpair::Socketpair(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : domain_(0)

  , protocol_(0)

  , type_(1)
{}
struct SocketpairDefaultTypeInternal {
  constexpr SocketpairDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SocketpairDefaultTypeInternal() {}
  union {
    Socketpair _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SocketpairDefaultTypeInternal _Socketpair_default_instance_;
constexpr NecpSessionOpen::NecpSessionOpen(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct NecpSessionOpenDefaultTypeInternal {
  constexpr NecpSessionOpenDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NecpSessionOpenDefaultTypeInternal() {}
  union {
    NecpSessionOpen _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NecpSessionOpenDefaultTypeInternal _NecpSessionOpen_default_instance_;
constexpr NecpSessionAction::NecpSessionAction(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : in_buffer_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , necp_fd_(0)

  , out_buffer_size_(0u)
  , action_(1)
{}
struct NecpSessionActionDefaultTypeInternal {
  constexpr NecpSessionActionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NecpSessionActionDefaultTypeInternal() {}
  union {
    NecpSessionAction _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NecpSessionActionDefaultTypeInternal _NecpSessionAction_default_instance_;
constexpr NecpMatchPolicy::NecpMatchPolicy(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : parameters_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct NecpMatchPolicyDefaultTypeInternal {
  constexpr NecpMatchPolicyDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NecpMatchPolicyDefaultTypeInternal() {}
  union {
    NecpMatchPolicy _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NecpMatchPolicyDefaultTypeInternal _NecpMatchPolicy_default_instance_;
constexpr NecpOpen::NecpOpen(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : flags_(){}
struct NecpOpenDefaultTypeInternal {
  constexpr NecpOpenDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NecpOpenDefaultTypeInternal() {}
  union {
    NecpOpen _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NecpOpenDefaultTypeInternal _NecpOpen_default_instance_;
constexpr NecpClientAction::NecpClientAction(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : necp_fd_(0)

  , client_id_(0)

  , _oneof_case_{}{}
struct NecpClientActionDefaultTypeInternal {
  constexpr NecpClientActionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NecpClientActionDefaultTypeInternal() {}
  union {
    NecpClientAction _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NecpClientActionDefaultTypeInternal _NecpClientAction_default_instance_;
constexpr NecpClientActionAdd::NecpClientActionAdd(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : buffer_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct NecpClientActionAddDefaultTypeInternal {
  constexpr NecpClientActionAddDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NecpClientActionAddDefaultTypeInternal() {}
  union {
    NecpClientActionAdd _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NecpClientActionAddDefaultTypeInternal _NecpClientActionAdd_default_instance_;
constexpr NecpClientActionRemove::NecpClientActionRemove(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct NecpClientActionRemoveDefaultTypeInternal {
  constexpr NecpClientActionRemoveDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NecpClientActionRemoveDefaultTypeInternal() {}
  union {
    NecpClientActionRemove _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NecpClientActionRemoveDefaultTypeInternal _NecpClientActionRemove_default_instance_;
constexpr NecpClientActionCopyParameters::NecpClientActionCopyParameters(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : copyout_size_(0u){}
struct NecpClientActionCopyParametersDefaultTypeInternal {
  constexpr NecpClientActionCopyParametersDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NecpClientActionCopyParametersDefaultTypeInternal() {}
  union {
    NecpClientActionCopyParameters _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NecpClientActionCopyParametersDefaultTypeInternal _NecpClientActionCopyParameters_default_instance_;
constexpr NecpClientActionAgent::NecpClientActionAgent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : necp_tlv_(){}
struct NecpClientActionAgentDefaultTypeInternal {
  constexpr NecpClientActionAgentDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NecpClientActionAgentDefaultTypeInternal() {}
  union {
    NecpClientActionAgent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NecpClientActionAgentDefaultTypeInternal _NecpClientActionAgent_default_instance_;
constexpr NecpTlv::NecpTlv(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , necp_type_(0u){}
struct NecpTlvDefaultTypeInternal {
  constexpr NecpTlvDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NecpTlvDefaultTypeInternal() {}
  union {
    NecpTlv _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NecpTlvDefaultTypeInternal _NecpTlv_default_instance_;
constexpr ClearAll::ClearAll(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct ClearAllDefaultTypeInternal {
  constexpr ClearAllDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ClearAllDefaultTypeInternal() {}
  union {
    ClearAll _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ClearAllDefaultTypeInternal _ClearAll_default_instance_;
constexpr Close::Close(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : fd_(0)
{}
struct CloseDefaultTypeInternal {
  constexpr CloseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CloseDefaultTypeInternal() {}
  union {
    Close _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CloseDefaultTypeInternal _Close_default_instance_;
constexpr Accept::Accept(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : sockaddr_(nullptr)
  , fd_(0)
{}
struct AcceptDefaultTypeInternal {
  constexpr AcceptDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AcceptDefaultTypeInternal() {}
  union {
    Accept _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AcceptDefaultTypeInternal _Accept_default_instance_;
constexpr Bind::Bind(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : sockaddr_(nullptr)
  , fd_(0)
{}
struct BindDefaultTypeInternal {
  constexpr BindDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BindDefaultTypeInternal() {}
  union {
    Bind _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BindDefaultTypeInternal _Bind_default_instance_;
constexpr Listen::Listen(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : socket_(0)

  , backlog_(0){}
struct ListenDefaultTypeInternal {
  constexpr ListenDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ListenDefaultTypeInternal() {}
  union {
    Listen _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ListenDefaultTypeInternal _Listen_default_instance_;
constexpr IoctlReal::IoctlReal(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : fd_(0)

  , _oneof_case_{}{}
struct IoctlRealDefaultTypeInternal {
  constexpr IoctlRealDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~IoctlRealDefaultTypeInternal() {}
  union {
    IoctlReal _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT IoctlRealDefaultTypeInternal _IoctlReal_default_instance_;
constexpr IfReqFlags::IfReqFlags(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : flags_()
  , ifr_name_(0)
{}
struct IfReqFlagsDefaultTypeInternal {
  constexpr IfReqFlagsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~IfReqFlagsDefaultTypeInternal() {}
  union {
    IfReqFlags _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT IfReqFlagsDefaultTypeInternal _IfReqFlags_default_instance_;
constexpr In6_AliasReq_64::In6_AliasReq_64(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : ifra_flags_()
  , ifra_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , ifra_addr_(nullptr)
  , ifra_dstaddr_(nullptr)
  , ifra_prefixmask_(nullptr)
  , ifra_lifetime_(nullptr){}
struct In6_AliasReq_64DefaultTypeInternal {
  constexpr In6_AliasReq_64DefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~In6_AliasReq_64DefaultTypeInternal() {}
  union {
    In6_AliasReq_64 _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT In6_AliasReq_64DefaultTypeInternal _In6_AliasReq_64_default_instance_;
constexpr In6AddrLifetime_64::In6AddrLifetime_64(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : ia6t_expire_(uint64_t{0u})
  , ia6t_preferred_(uint64_t{0u})
  , ia6t_vltime_(0u)
  , ia6t_pltime_(0u){}
struct In6AddrLifetime_64DefaultTypeInternal {
  constexpr In6AddrLifetime_64DefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~In6AddrLifetime_64DefaultTypeInternal() {}
  union {
    In6AddrLifetime_64 _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT In6AddrLifetime_64DefaultTypeInternal _In6AddrLifetime_64_default_instance_;
constexpr Packet::Packet(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct PacketDefaultTypeInternal {
  constexpr PacketDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~PacketDefaultTypeInternal() {}
  union {
    Packet _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PacketDefaultTypeInternal _Packet_default_instance_;
constexpr TcpPacket::TcpPacket(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , ip_hdr_(nullptr)
  , tcp_hdr_(nullptr){}
struct TcpPacketDefaultTypeInternal {
  constexpr TcpPacketDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~TcpPacketDefaultTypeInternal() {}
  union {
    TcpPacket _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TcpPacketDefaultTypeInternal _TcpPacket_default_instance_;
constexpr Tcp6Packet::Tcp6Packet(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , ip6_hdr_(nullptr)
  , tcp_hdr_(nullptr){}
struct Tcp6PacketDefaultTypeInternal {
  constexpr Tcp6PacketDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Tcp6PacketDefaultTypeInternal() {}
  union {
    Tcp6Packet _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Tcp6PacketDefaultTypeInternal _Tcp6Packet_default_instance_;
constexpr Ip4Packet::Ip4Packet(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , ip_hdr_(nullptr){}
struct Ip4PacketDefaultTypeInternal {
  constexpr Ip4PacketDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Ip4PacketDefaultTypeInternal() {}
  union {
    Ip4Packet _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Ip4PacketDefaultTypeInternal _Ip4Packet_default_instance_;
constexpr Ip6Packet::Ip6Packet(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , ip6_hdr_(nullptr){}
struct Ip6PacketDefaultTypeInternal {
  constexpr Ip6PacketDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Ip6PacketDefaultTypeInternal() {}
  union {
    Ip6Packet _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Ip6PacketDefaultTypeInternal _Ip6Packet_default_instance_;
constexpr Ip6Ext::Ip6Ext(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : ip6e_nxt_(0)

  , ip6e_len_(0u){}
struct Ip6ExtDefaultTypeInternal {
  constexpr Ip6ExtDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Ip6ExtDefaultTypeInternal() {}
  union {
    Ip6Ext _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Ip6ExtDefaultTypeInternal _Ip6Ext_default_instance_;
constexpr Ip6RtHdr::Ip6RtHdr(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : ip6r_nxt_(0)

  , ip6r_len_(0u)
  , ip6r_type_(0)

  , ip6r_segleft_(0u){}
struct Ip6RtHdrDefaultTypeInternal {
  constexpr Ip6RtHdrDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Ip6RtHdrDefaultTypeInternal() {}
  union {
    Ip6RtHdr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Ip6RtHdrDefaultTypeInternal _Ip6RtHdr_default_instance_;
constexpr Ip6Rt0Hdr::Ip6Rt0Hdr(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : ip6r0_addr_()
  , ip6r0_nxt_(0)

  , ip6r0_len_(0u)
  , ip6r0_type_(0u)
  , ip6r0_segleft_(0u)
  , ip6r0_reserved_(0u)
  , ip6r0_slmap_(0u){}
struct Ip6Rt0HdrDefaultTypeInternal {
  constexpr Ip6Rt0HdrDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Ip6Rt0HdrDefaultTypeInternal() {}
  union {
    Ip6Rt0Hdr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Ip6Rt0HdrDefaultTypeInternal _Ip6Rt0Hdr_default_instance_;
constexpr Ip6FragHdr::Ip6FragHdr(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : ip6f_nxt_(0)

  , ip6f_reserved_(0u)
  , ip6f_offlg_(0u)
  , ip6f_ident_(0u){}
struct Ip6FragHdrDefaultTypeInternal {
  constexpr Ip6FragHdrDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Ip6FragHdrDefaultTypeInternal() {}
  union {
    Ip6FragHdr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Ip6FragHdrDefaultTypeInternal _Ip6FragHdr_default_instance_;
constexpr Icmp6Hdr::Icmp6Hdr(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : icmp6_code_(0)

  , icmp6_dataun_(0u)
  , icmp6_type_(1)
{}
struct Icmp6HdrDefaultTypeInternal {
  constexpr Icmp6HdrDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Icmp6HdrDefaultTypeInternal() {}
  union {
    Icmp6Hdr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Icmp6HdrDefaultTypeInternal _Icmp6Hdr_default_instance_;
constexpr TcpHdr::TcpHdr(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : th_flags_()
  , th_sport_(0)

  , th_dport_(0)

  , th_off_(0u)
  , th_win_(0u)
  , th_sum_(0u)
  , th_urp_(0u)
  , is_pure_syn_(false)
  , is_pure_ack_(false)
  , th_seq_(1)

  , th_ack_(1)
{}
struct TcpHdrDefaultTypeInternal {
  constexpr TcpHdrDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~TcpHdrDefaultTypeInternal() {}
  union {
    TcpHdr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TcpHdrDefaultTypeInternal _TcpHdr_default_instance_;
constexpr IpHdr::IpHdr(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : ip_hl_(0u)
  , ip_tos_(0u)
  , ip_len_(0u)
  , ip_id_(0u)
  , ip_off_(0u)
  , ip_ttl_(0u)
  , ip_p_(0)

  , ip_src_(0)

  , ip_dst_(0)

  , ip_v_(4)
{}
struct IpHdrDefaultTypeInternal {
  constexpr IpHdrDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~IpHdrDefaultTypeInternal() {}
  union {
    IpHdr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT IpHdrDefaultTypeInternal _IpHdr_default_instance_;
constexpr Ip6Hdr::Ip6Hdr(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : ip6_hdrctl_(nullptr)
  , ip6_src_(0)

  , ip6_dst_(0)
{}
struct Ip6HdrDefaultTypeInternal {
  constexpr Ip6HdrDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Ip6HdrDefaultTypeInternal() {}
  union {
    Ip6Hdr _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Ip6HdrDefaultTypeInternal _Ip6Hdr_default_instance_;
constexpr Ip6Hdrctl::Ip6Hdrctl(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : ip6_un1_flow_(0u)
  , ip6_un1_plen_(0u)
  , ip6_un1_nxt_(0)

  , ip6_un1_hlim_(0u){}
struct Ip6HdrctlDefaultTypeInternal {
  constexpr Ip6HdrctlDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Ip6HdrctlDefaultTypeInternal() {}
  union {
    Ip6Hdrctl _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Ip6HdrctlDefaultTypeInternal _Ip6Hdrctl_default_instance_;
constexpr Key::Key(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : mbuf_data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct KeyDefaultTypeInternal {
  constexpr KeyDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~KeyDefaultTypeInternal() {}
  union {
    Key _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT KeyDefaultTypeInternal _Key_default_instance_;
constexpr Ioctl::Ioctl(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : fd_(0)

  , ioctl_idx_(1)
{}
struct IoctlDefaultTypeInternal {
  constexpr IoctlDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~IoctlDefaultTypeInternal() {}
  union {
    Ioctl _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT IoctlDefaultTypeInternal _Ioctl_default_instance_;
constexpr SetSocketOpt::SetSocketOpt(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : val_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , level_(0)

  , fd_(0)

  , name_(1)
{}
struct SetSocketOptDefaultTypeInternal {
  constexpr SetSocketOptDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SetSocketOptDefaultTypeInternal() {}
  union {
    SetSocketOpt _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SetSocketOptDefaultTypeInternal _SetSocketOpt_default_instance_;
constexpr GetSocketOpt::GetSocketOpt(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : level_(0)

  , size_(0)
  , fd_(0u)
  , name_(1)
{}
struct GetSocketOptDefaultTypeInternal {
  constexpr GetSocketOptDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~GetSocketOptDefaultTypeInternal() {}
  union {
    GetSocketOpt _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetSocketOptDefaultTypeInternal _GetSocketOpt_default_instance_;
constexpr Socket::Socket(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : domain_(0)

  , protocol_(0)

  , so_type_(1)
{}
struct SocketDefaultTypeInternal {
  constexpr SocketDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SocketDefaultTypeInternal() {}
  union {
    Socket _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SocketDefaultTypeInternal _Socket_default_instance_;
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_net_5ffuzzer_2eproto[62];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_net_5ffuzzer_2eproto[28];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_net_5ffuzzer_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_net_5ffuzzer_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::Session, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Session, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Session, commands_),
  PROTOBUF_FIELD_OFFSET(::Session, data_provider_),
  ~0u,
  0,
  PROTOBUF_FIELD_OFFSET(::Connect, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Connect, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Connect, sockaddr_),
  PROTOBUF_FIELD_OFFSET(::Connect, fd_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::ConnectX, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::ConnectX, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::ConnectX, socket_),
  PROTOBUF_FIELD_OFFSET(::ConnectX, endpoints_),
  PROTOBUF_FIELD_OFFSET(::ConnectX, associd_),
  PROTOBUF_FIELD_OFFSET(::ConnectX, flags_),
  1,
  0,
  2,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::DisconnectX, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::DisconnectX, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::DisconnectX, associd_),
  PROTOBUF_FIELD_OFFSET(::DisconnectX, cid_),
  PROTOBUF_FIELD_OFFSET(::DisconnectX, fd_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::IOV, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::IOV, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::IOV, iov_data_),
  0,
  PROTOBUF_FIELD_OFFSET(::Endpoints, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Endpoints, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Endpoints, sae_srcif_),
  PROTOBUF_FIELD_OFFSET(::Endpoints, sae_srcaddr_),
  PROTOBUF_FIELD_OFFSET(::Endpoints, sae_dstaddr_),
  2,
  0,
  1,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::SockAddr, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::SockAddr, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::SockAddr, sockaddr_),
  PROTOBUF_FIELD_OFFSET(::SockAddrGeneric, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SockAddrGeneric, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::SockAddrGeneric, sa_family_),
  PROTOBUF_FIELD_OFFSET(::SockAddrGeneric, sa_data_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::SockAddr4, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SockAddr4, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::SockAddr4, sin_family_),
  PROTOBUF_FIELD_OFFSET(::SockAddr4, sin_port_),
  PROTOBUF_FIELD_OFFSET(::SockAddr4, sin_addr_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::SockAddr6, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SockAddr6, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::SockAddr6, family_),
  PROTOBUF_FIELD_OFFSET(::SockAddr6, port_),
  PROTOBUF_FIELD_OFFSET(::SockAddr6, flow_info_),
  PROTOBUF_FIELD_OFFSET(::SockAddr6, sin6_addr_),
  PROTOBUF_FIELD_OFFSET(::SockAddr6, sin6_scope_id_),
  0,
  1,
  2,
  3,
  4,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::Command, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::Command, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::Command, command_),
  PROTOBUF_FIELD_OFFSET(::AcceptNocancel, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::AcceptNocancel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::AcceptNocancel, s_),
  PROTOBUF_FIELD_OFFSET(::AcceptNocancel, name_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::ConnectNocancel, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::ConnectNocancel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::ConnectNocancel, s_),
  PROTOBUF_FIELD_OFFSET(::ConnectNocancel, name_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::Getpeername, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Getpeername, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Getpeername, fdes_),
  PROTOBUF_FIELD_OFFSET(::Getpeername, asa_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::Getsockname, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Getsockname, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Getsockname, fdes_),
  PROTOBUF_FIELD_OFFSET(::Getsockname, asa_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::Peeloff, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Peeloff, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Peeloff, s_),
  PROTOBUF_FIELD_OFFSET(::Peeloff, aid_),
  0,
  1,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::Pipe, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Shutdown, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Shutdown, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Shutdown, s_),
  PROTOBUF_FIELD_OFFSET(::Shutdown, how_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::Recvfrom, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Recvfrom, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Recvfrom, s_),
  PROTOBUF_FIELD_OFFSET(::Recvfrom, buf_),
  PROTOBUF_FIELD_OFFSET(::Recvfrom, flags_),
  PROTOBUF_FIELD_OFFSET(::Recvfrom, from_),
  2,
  0,
  3,
  1,
  PROTOBUF_FIELD_OFFSET(::RecvfromNocancel, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::RecvfromNocancel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::RecvfromNocancel, s_),
  PROTOBUF_FIELD_OFFSET(::RecvfromNocancel, buf_),
  PROTOBUF_FIELD_OFFSET(::RecvfromNocancel, flags_),
  PROTOBUF_FIELD_OFFSET(::RecvfromNocancel, from_),
  2,
  0,
  3,
  1,
  PROTOBUF_FIELD_OFFSET(::Recvmsg, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Recvmsg, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Recvmsg, s_),
  PROTOBUF_FIELD_OFFSET(::Recvmsg, flags_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::Sendmsg, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Sendmsg, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Sendmsg, s_),
  PROTOBUF_FIELD_OFFSET(::Sendmsg, msg_),
  PROTOBUF_FIELD_OFFSET(::Sendmsg, flags_),
  1,
  0,
  2,
  PROTOBUF_FIELD_OFFSET(::Sendto, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Sendto, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Sendto, s_),
  PROTOBUF_FIELD_OFFSET(::Sendto, buf_),
  PROTOBUF_FIELD_OFFSET(::Sendto, flags_),
  PROTOBUF_FIELD_OFFSET(::Sendto, to_),
  2,
  0,
  3,
  1,
  PROTOBUF_FIELD_OFFSET(::Socketpair, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Socketpair, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Socketpair, domain_),
  PROTOBUF_FIELD_OFFSET(::Socketpair, type_),
  PROTOBUF_FIELD_OFFSET(::Socketpair, protocol_),
  0,
  2,
  1,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::NecpSessionOpen, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::NecpSessionAction, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::NecpSessionAction, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::NecpSessionAction, necp_fd_),
  PROTOBUF_FIELD_OFFSET(::NecpSessionAction, action_),
  PROTOBUF_FIELD_OFFSET(::NecpSessionAction, in_buffer_),
  PROTOBUF_FIELD_OFFSET(::NecpSessionAction, out_buffer_size_),
  1,
  3,
  0,
  2,
  PROTOBUF_FIELD_OFFSET(::NecpMatchPolicy, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::NecpMatchPolicy, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::NecpMatchPolicy, parameters_),
  0,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::NecpOpen, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::NecpOpen, flags_),
  PROTOBUF_FIELD_OFFSET(::NecpClientAction, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::NecpClientAction, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::NecpClientAction, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::NecpClientAction, necp_fd_),
  PROTOBUF_FIELD_OFFSET(::NecpClientAction, client_id_),
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::NecpClientAction, action_),
  0,
  1,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::NecpClientActionAdd, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::NecpClientActionAdd, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::NecpClientActionAdd, buffer_),
  0,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::NecpClientActionRemove, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::NecpClientActionCopyParameters, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::NecpClientActionCopyParameters, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::NecpClientActionCopyParameters, copyout_size_),
  0,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::NecpClientActionAgent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::NecpClientActionAgent, necp_tlv_),
  PROTOBUF_FIELD_OFFSET(::NecpTlv, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::NecpTlv, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::NecpTlv, necp_type_),
  PROTOBUF_FIELD_OFFSET(::NecpTlv, data_),
  1,
  0,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::ClearAll, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Close, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Close, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Close, fd_),
  0,
  PROTOBUF_FIELD_OFFSET(::Accept, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Accept, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Accept, sockaddr_),
  PROTOBUF_FIELD_OFFSET(::Accept, fd_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::Bind, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Bind, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Bind, sockaddr_),
  PROTOBUF_FIELD_OFFSET(::Bind, fd_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::Listen, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Listen, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Listen, socket_),
  PROTOBUF_FIELD_OFFSET(::Listen, backlog_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::IoctlReal, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::IoctlReal, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::IoctlReal, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::IoctlReal, fd_),
  PROTOBUF_FIELD_OFFSET(::IoctlReal, ioctl_),
  ~0u,
  ~0u,
  0,
  PROTOBUF_FIELD_OFFSET(::IfReqFlags, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::IfReqFlags, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::IfReqFlags, ifr_name_),
  PROTOBUF_FIELD_OFFSET(::IfReqFlags, flags_),
  0,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::In6_AliasReq_64, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::In6_AliasReq_64, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::In6_AliasReq_64, ifra_name_),
  PROTOBUF_FIELD_OFFSET(::In6_AliasReq_64, ifra_addr_),
  PROTOBUF_FIELD_OFFSET(::In6_AliasReq_64, ifra_dstaddr_),
  PROTOBUF_FIELD_OFFSET(::In6_AliasReq_64, ifra_prefixmask_),
  PROTOBUF_FIELD_OFFSET(::In6_AliasReq_64, ifra_flags_),
  PROTOBUF_FIELD_OFFSET(::In6_AliasReq_64, ifra_lifetime_),
  0,
  1,
  2,
  3,
  ~0u,
  4,
  PROTOBUF_FIELD_OFFSET(::In6AddrLifetime_64, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::In6AddrLifetime_64, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::In6AddrLifetime_64, ia6t_expire_),
  PROTOBUF_FIELD_OFFSET(::In6AddrLifetime_64, ia6t_preferred_),
  PROTOBUF_FIELD_OFFSET(::In6AddrLifetime_64, ia6t_vltime_),
  PROTOBUF_FIELD_OFFSET(::In6AddrLifetime_64, ia6t_pltime_),
  0,
  1,
  2,
  3,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::Packet, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::Packet, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::Packet, packet_),
  PROTOBUF_FIELD_OFFSET(::TcpPacket, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::TcpPacket, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::TcpPacket, ip_hdr_),
  PROTOBUF_FIELD_OFFSET(::TcpPacket, tcp_hdr_),
  PROTOBUF_FIELD_OFFSET(::TcpPacket, data_),
  1,
  2,
  0,
  PROTOBUF_FIELD_OFFSET(::Tcp6Packet, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Tcp6Packet, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Tcp6Packet, ip6_hdr_),
  PROTOBUF_FIELD_OFFSET(::Tcp6Packet, tcp_hdr_),
  PROTOBUF_FIELD_OFFSET(::Tcp6Packet, data_),
  1,
  2,
  0,
  PROTOBUF_FIELD_OFFSET(::Ip4Packet, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Ip4Packet, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Ip4Packet, ip_hdr_),
  PROTOBUF_FIELD_OFFSET(::Ip4Packet, data_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::Ip6Packet, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Ip6Packet, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Ip6Packet, ip6_hdr_),
  PROTOBUF_FIELD_OFFSET(::Ip6Packet, data_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::Ip6Ext, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Ip6Ext, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Ip6Ext, ip6e_nxt_),
  PROTOBUF_FIELD_OFFSET(::Ip6Ext, ip6e_len_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::Ip6RtHdr, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Ip6RtHdr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Ip6RtHdr, ip6r_nxt_),
  PROTOBUF_FIELD_OFFSET(::Ip6RtHdr, ip6r_len_),
  PROTOBUF_FIELD_OFFSET(::Ip6RtHdr, ip6r_type_),
  PROTOBUF_FIELD_OFFSET(::Ip6RtHdr, ip6r_segleft_),
  0,
  1,
  2,
  3,
  PROTOBUF_FIELD_OFFSET(::Ip6Rt0Hdr, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Ip6Rt0Hdr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Ip6Rt0Hdr, ip6r0_nxt_),
  PROTOBUF_FIELD_OFFSET(::Ip6Rt0Hdr, ip6r0_len_),
  PROTOBUF_FIELD_OFFSET(::Ip6Rt0Hdr, ip6r0_type_),
  PROTOBUF_FIELD_OFFSET(::Ip6Rt0Hdr, ip6r0_segleft_),
  PROTOBUF_FIELD_OFFSET(::Ip6Rt0Hdr, ip6r0_reserved_),
  PROTOBUF_FIELD_OFFSET(::Ip6Rt0Hdr, ip6r0_slmap_),
  PROTOBUF_FIELD_OFFSET(::Ip6Rt0Hdr, ip6r0_addr_),
  0,
  1,
  2,
  3,
  4,
  5,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::Ip6FragHdr, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Ip6FragHdr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Ip6FragHdr, ip6f_nxt_),
  PROTOBUF_FIELD_OFFSET(::Ip6FragHdr, ip6f_reserved_),
  PROTOBUF_FIELD_OFFSET(::Ip6FragHdr, ip6f_offlg_),
  PROTOBUF_FIELD_OFFSET(::Ip6FragHdr, ip6f_ident_),
  0,
  1,
  2,
  3,
  PROTOBUF_FIELD_OFFSET(::Icmp6Hdr, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Icmp6Hdr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Icmp6Hdr, icmp6_type_),
  PROTOBUF_FIELD_OFFSET(::Icmp6Hdr, icmp6_code_),
  PROTOBUF_FIELD_OFFSET(::Icmp6Hdr, icmp6_dataun_),
  2,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::TcpHdr, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::TcpHdr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::TcpHdr, th_sport_),
  PROTOBUF_FIELD_OFFSET(::TcpHdr, th_dport_),
  PROTOBUF_FIELD_OFFSET(::TcpHdr, th_seq_),
  PROTOBUF_FIELD_OFFSET(::TcpHdr, th_ack_),
  PROTOBUF_FIELD_OFFSET(::TcpHdr, th_off_),
  PROTOBUF_FIELD_OFFSET(::TcpHdr, th_flags_),
  PROTOBUF_FIELD_OFFSET(::TcpHdr, th_win_),
  PROTOBUF_FIELD_OFFSET(::TcpHdr, th_sum_),
  PROTOBUF_FIELD_OFFSET(::TcpHdr, th_urp_),
  PROTOBUF_FIELD_OFFSET(::TcpHdr, is_pure_syn_),
  PROTOBUF_FIELD_OFFSET(::TcpHdr, is_pure_ack_),
  0,
  1,
  8,
  9,
  2,
  ~0u,
  3,
  4,
  5,
  6,
  7,
  PROTOBUF_FIELD_OFFSET(::IpHdr, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::IpHdr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::IpHdr, ip_hl_),
  PROTOBUF_FIELD_OFFSET(::IpHdr, ip_v_),
  PROTOBUF_FIELD_OFFSET(::IpHdr, ip_tos_),
  PROTOBUF_FIELD_OFFSET(::IpHdr, ip_len_),
  PROTOBUF_FIELD_OFFSET(::IpHdr, ip_id_),
  PROTOBUF_FIELD_OFFSET(::IpHdr, ip_off_),
  PROTOBUF_FIELD_OFFSET(::IpHdr, ip_ttl_),
  PROTOBUF_FIELD_OFFSET(::IpHdr, ip_p_),
  PROTOBUF_FIELD_OFFSET(::IpHdr, ip_src_),
  PROTOBUF_FIELD_OFFSET(::IpHdr, ip_dst_),
  0,
  9,
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  PROTOBUF_FIELD_OFFSET(::Ip6Hdr, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Ip6Hdr, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Ip6Hdr, ip6_hdrctl_),
  PROTOBUF_FIELD_OFFSET(::Ip6Hdr, ip6_src_),
  PROTOBUF_FIELD_OFFSET(::Ip6Hdr, ip6_dst_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::Ip6Hdrctl, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Ip6Hdrctl, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Ip6Hdrctl, ip6_un1_flow_),
  PROTOBUF_FIELD_OFFSET(::Ip6Hdrctl, ip6_un1_plen_),
  PROTOBUF_FIELD_OFFSET(::Ip6Hdrctl, ip6_un1_nxt_),
  PROTOBUF_FIELD_OFFSET(::Ip6Hdrctl, ip6_un1_hlim_),
  0,
  1,
  2,
  3,
  PROTOBUF_FIELD_OFFSET(::Key, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Key, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Key, mbuf_data_),
  0,
  PROTOBUF_FIELD_OFFSET(::Ioctl, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Ioctl, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Ioctl, ioctl_idx_),
  PROTOBUF_FIELD_OFFSET(::Ioctl, fd_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::SetSocketOpt, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SetSocketOpt, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::SetSocketOpt, level_),
  PROTOBUF_FIELD_OFFSET(::SetSocketOpt, name_),
  PROTOBUF_FIELD_OFFSET(::SetSocketOpt, val_),
  PROTOBUF_FIELD_OFFSET(::SetSocketOpt, fd_),
  1,
  3,
  0,
  2,
  PROTOBUF_FIELD_OFFSET(::GetSocketOpt, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::GetSocketOpt, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::GetSocketOpt, level_),
  PROTOBUF_FIELD_OFFSET(::GetSocketOpt, name_),
  PROTOBUF_FIELD_OFFSET(::GetSocketOpt, size_),
  PROTOBUF_FIELD_OFFSET(::GetSocketOpt, fd_),
  0,
  3,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::Socket, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Socket, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::Socket, domain_),
  PROTOBUF_FIELD_OFFSET(::Socket, so_type_),
  PROTOBUF_FIELD_OFFSET(::Socket, protocol_),
  0,
  2,
  1,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 8, -1, sizeof(::Session)},
  { 10, 18, -1, sizeof(::Connect)},
  { 20, 30, -1, sizeof(::ConnectX)},
  { 34, 43, -1, sizeof(::DisconnectX)},
  { 46, 53, -1, sizeof(::IOV)},
  { 54, 63, -1, sizeof(::Endpoints)},
  { 66, -1, -1, sizeof(::SockAddr)},
  { 76, 84, -1, sizeof(::SockAddrGeneric)},
  { 86, 95, -1, sizeof(::SockAddr4)},
  { 98, 109, -1, sizeof(::SockAddr6)},
  { 114, -1, -1, sizeof(::Command)},
  { 152, 160, -1, sizeof(::AcceptNocancel)},
  { 162, 170, -1, sizeof(::ConnectNocancel)},
  { 172, 180, -1, sizeof(::Getpeername)},
  { 182, 190, -1, sizeof(::Getsockname)},
  { 192, 200, -1, sizeof(::Peeloff)},
  { 202, -1, -1, sizeof(::Pipe)},
  { 208, 216, -1, sizeof(::Shutdown)},
  { 218, 228, -1, sizeof(::Recvfrom)},
  { 232, 242, -1, sizeof(::RecvfromNocancel)},
  { 246, 254, -1, sizeof(::Recvmsg)},
  { 256, 265, -1, sizeof(::Sendmsg)},
  { 268, 278, -1, sizeof(::Sendto)},
  { 282, 291, -1, sizeof(::Socketpair)},
  { 294, -1, -1, sizeof(::NecpSessionOpen)},
  { 300, 310, -1, sizeof(::NecpSessionAction)},
  { 314, 321, -1, sizeof(::NecpMatchPolicy)},
  { 322, -1, -1, sizeof(::NecpOpen)},
  { 329, 342, -1, sizeof(::NecpClientAction)},
  { 348, 355, -1, sizeof(::NecpClientActionAdd)},
  { 356, -1, -1, sizeof(::NecpClientActionRemove)},
  { 362, 369, -1, sizeof(::NecpClientActionCopyParameters)},
  { 370, -1, -1, sizeof(::NecpClientActionAgent)},
  { 377, 385, -1, sizeof(::NecpTlv)},
  { 387, -1, -1, sizeof(::ClearAll)},
  { 393, 400, -1, sizeof(::Close)},
  { 401, 409, -1, sizeof(::Accept)},
  { 411, 419, -1, sizeof(::Bind)},
  { 421, 429, -1, sizeof(::Listen)},
  { 431, 441, -1, sizeof(::IoctlReal)},
  { 444, 452, -1, sizeof(::IfReqFlags)},
  { 454, 466, -1, sizeof(::In6_AliasReq_64)},
  { 472, 482, -1, sizeof(::In6AddrLifetime_64)},
  { 486, -1, -1, sizeof(::Packet)},
  { 499, 508, -1, sizeof(::TcpPacket)},
  { 511, 520, -1, sizeof(::Tcp6Packet)},
  { 523, 531, -1, sizeof(::Ip4Packet)},
  { 533, 541, -1, sizeof(::Ip6Packet)},
  { 543, 551, -1, sizeof(::Ip6Ext)},
  { 553, 563, -1, sizeof(::Ip6RtHdr)},
  { 567, 580, -1, sizeof(::Ip6Rt0Hdr)},
  { 587, 597, -1, sizeof(::Ip6FragHdr)},
  { 601, 610, -1, sizeof(::Icmp6Hdr)},
  { 613, 630, -1, sizeof(::TcpHdr)},
  { 641, 657, -1, sizeof(::IpHdr)},
  { 667, 676, -1, sizeof(::Ip6Hdr)},
  { 679, 689, -1, sizeof(::Ip6Hdrctl)},
  { 693, 700, -1, sizeof(::Key)},
  { 701, 709, -1, sizeof(::Ioctl)},
  { 711, 721, -1, sizeof(::SetSocketOpt)},
  { 725, 735, -1, sizeof(::GetSocketOpt)},
  { 739, 748, -1, sizeof(::Socket)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Session_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Connect_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_ConnectX_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_DisconnectX_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_IOV_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Endpoints_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_SockAddr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_SockAddrGeneric_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_SockAddr4_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_SockAddr6_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Command_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_AcceptNocancel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_ConnectNocancel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Getpeername_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Getsockname_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Peeloff_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Pipe_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Shutdown_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Recvfrom_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_RecvfromNocancel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Recvmsg_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Sendmsg_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Sendto_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Socketpair_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_NecpSessionOpen_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_NecpSessionAction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_NecpMatchPolicy_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_NecpOpen_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_NecpClientAction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_NecpClientActionAdd_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_NecpClientActionRemove_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_NecpClientActionCopyParameters_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_NecpClientActionAgent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_NecpTlv_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_ClearAll_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Close_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Accept_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Bind_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Listen_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_IoctlReal_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_IfReqFlags_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_In6_AliasReq_64_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_In6AddrLifetime_64_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Packet_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_TcpPacket_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Tcp6Packet_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Ip4Packet_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Ip6Packet_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Ip6Ext_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Ip6RtHdr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Ip6Rt0Hdr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Ip6FragHdr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Icmp6Hdr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_TcpHdr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_IpHdr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Ip6Hdr_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Ip6Hdrctl_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Key_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Ioctl_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_SetSocketOpt_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_GetSocketOpt_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Socket_default_instance_),
};

const char descriptor_table_protodef_net_5ffuzzer_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\020net_fuzzer.proto\"<\n\007Session\022\032\n\010command"
  "s\030\001 \003(\0132\010.Command\022\025\n\rdata_provider\030\002 \002(\014"
  "\"C\n\007Connect\022\033\n\010sockaddr\030\001 \002(\0132\t.SockAddr"
  "\022\033\n\002fd\030\002 \002(\0162\017.FileDescriptor\"\206\001\n\010Connec"
  "tX\022\037\n\006socket\030\001 \002(\0162\017.FileDescriptor\022\035\n\te"
  "ndpoints\030\002 \002(\0132\n.Endpoints\022\034\n\007associd\030\003 "
  "\002(\0162\013.SaeAssocID\022\034\n\005flags\030\004 \003(\0162\r.Connec"
  "tXFlag\"U\n\013DisconnectX\022\034\n\007associd\030\001 \002(\0162\013"
  ".SaeAssocID\022\013\n\003cid\030\002 \002(\005\022\033\n\002fd\030\003 \002(\0162\017.F"
  "ileDescriptor\"\027\n\003IOV\022\020\n\010iov_data\030\001 \002(\014\"f"
  "\n\tEndpoints\022\031\n\tsae_srcif\030\001 \002(\0162\006.IfIdx\022\036"
  "\n\013sae_srcaddr\030\002 \001(\0132\t.SockAddr\022\036\n\013sae_ds"
  "taddr\030\003 \002(\0132\t.SockAddr\"\206\001\n\010SockAddr\022,\n\020s"
  "ockaddr_generic\030\001 \001(\0132\020.SockAddrGenericH"
  "\000\022\037\n\tsockaddr4\030\002 \001(\0132\n.SockAddr4H\000\022\037\n\tso"
  "ckaddr6\030\003 \001(\0132\n.SockAddr6H\000B\n\n\010sockaddr\""
  ">\n\017SockAddrGeneric\022\032\n\tsa_family\030\001 \002(\0162\007."
  "Domain\022\017\n\007sa_data\030\002 \002(\014\"\\\n\tSockAddr4\022\033\n\n"
  "sin_family\030\001 \002(\0162\007.Domain\022\027\n\010sin_port\030\002 "
  "\002(\0162\005.Port\022\031\n\010sin_addr\030\003 \002(\0162\007.InAddr\"\225\001"
  "\n\tSockAddr6\022\027\n\006family\030\001 \002(\0162\007.Domain\022\023\n\004"
  "port\030\002 \002(\0162\005.Port\022\034\n\tflow_info\030\003 \002(\0162\t.F"
  "lowInfo\022\033\n\tsin6_addr\030\004 \002(\0162\010.In6Addr\022\037\n\r"
  "sin6_scope_id\030\005 \002(\0162\010.ScopeId\"\277\010\n\007Comman"
  "d\022\033\n\010ip_input\030\001 \001(\0132\007.PacketH\000\022\027\n\005ioctl\030"
  "\003 \001(\0132\006.IoctlH\000\022%\n\014set_sock_opt\030\004 \001(\0132\r."
  "SetSocketOptH\000\022 \n\nioctl_real\030\005 \001(\0132\n.Ioc"
  "tlRealH\000\022\035\n\010connectx\030\006 \001(\0132\t.ConnectXH\000\022"
  "\033\n\007connect\030\007 \001(\0132\010.ConnectH\000\022\031\n\006listen\030\010"
  " \001(\0132\007.ListenH\000\022#\n\013disconnectx\030\t \001(\0132\014.D"
  "isconnectXH\000\022%\n\014get_sock_opt\030\n \001(\0132\r.Get"
  "SocketOptH\000\022\025\n\004bind\030\013 \001(\0132\005.BindH\000\022\031\n\006ac"
  "cept\030\014 \001(\0132\007.AcceptH\000\022\031\n\006socket\030\r \001(\0132\007."
  "SocketH\000\022\027\n\005close\030\016 \001(\0132\006.CloseH\000\022\036\n\tcle"
  "ar_all\030\017 \001(\0132\t.ClearAllH\000\022-\n\021necp_match_"
  "policy\030\020 \001(\0132\020.NecpMatchPolicyH\000\022\036\n\tnecp"
  "_open\030\021 \001(\0132\t.NecpOpenH\000\022/\n\022necp_client_"
  "action\030\022 \001(\0132\021.NecpClientActionH\000\022-\n\021nec"
  "p_session_open\030\023 \001(\0132\020.NecpSessionOpenH\000"
  "\0221\n\023necp_session_action\030\024 \001(\0132\022.NecpSess"
  "ionActionH\000\022*\n\017accept_nocancel\030\025 \001(\0132\017.A"
  "cceptNocancelH\000\022,\n\020connect_nocancel\030\026 \001("
  "\0132\020.ConnectNocancelH\000\022#\n\013getpeername\030\027 \001"
  "(\0132\014.GetpeernameH\000\022#\n\013getsockname\030\030 \001(\0132"
  "\014.GetsocknameH\000\022\033\n\007peeloff\030\031 \001(\0132\010.Peelo"
  "ffH\000\022\035\n\010recvfrom\030\032 \001(\0132\t.RecvfromH\000\022.\n\021r"
  "ecvfrom_nocancel\030\033 \001(\0132\021.RecvfromNocance"
  "lH\000\022\033\n\007recvmsg\030\034 \001(\0132\010.RecvmsgH\000\022\031\n\006send"
  "to\030\" \001(\0132\007.SendtoH\000\022!\n\nsocketpair\030& \001(\0132"
  "\013.SocketpairH\000\022\025\n\004pipe\030\' \001(\0132\005.PipeH\000\022\035\n"
  "\010shutdown\030( \001(\0132\t.ShutdownH\000B\t\n\007command\""
  "E\n\016AcceptNocancel\022\032\n\001s\030\001 \001(\0162\017.FileDescr"
  "iptor\022\027\n\004name\030\002 \001(\0132\t.SockAddr\"F\n\017Connec"
  "tNocancel\022\032\n\001s\030\001 \001(\0162\017.FileDescriptor\022\027\n"
  "\004name\030\002 \001(\0132\t.SockAddr\"D\n\013Getpeername\022\035\n"
  "\004fdes\030\001 \001(\0162\017.FileDescriptor\022\026\n\003asa\030\002 \001("
  "\0132\t.SockAddr\"D\n\013Getsockname\022\035\n\004fdes\030\001 \001("
  "\0162\017.FileDescriptor\022\026\n\003asa\030\002 \001(\0132\t.SockAd"
  "dr\"\?\n\007Peeloff\022\032\n\001s\030\001 \001(\0162\017.FileDescripto"
  "r\022\030\n\003aid\030\002 \001(\0162\013.SaeAssocID\"\006\n\004Pipe\"A\n\010S"
  "hutdown\022\032\n\001s\030\001 \001(\0162\017.FileDescriptor\022\031\n\003h"
  "ow\030\002 \001(\0162\014.ShutdownHow\"[\n\010Recvfrom\022\032\n\001s\030"
  "\001 \001(\0162\017.FileDescriptor\022\013\n\003buf\030\002 \001(\014\022\r\n\005f"
  "lags\030\003 \001(\005\022\027\n\004from\030\004 \001(\0132\t.SockAddr\"c\n\020R"
  "ecvfromNocancel\022\032\n\001s\030\001 \001(\0162\017.FileDescrip"
  "tor\022\013\n\003buf\030\002 \001(\014\022\r\n\005flags\030\003 \001(\005\022\027\n\004from\030"
  "\004 \001(\0132\t.SockAddr\"4\n\007Recvmsg\022\032\n\001s\030\001 \001(\0162\017"
  ".FileDescriptor\022\r\n\005flags\030\002 \001(\r\"A\n\007Sendms"
  "g\022\032\n\001s\030\001 \001(\0162\017.FileDescriptor\022\013\n\003msg\030\002 \001"
  "(\014\022\r\n\005flags\030\003 \001(\r\"W\n\006Sendto\022\032\n\001s\030\001 \001(\0162\017"
  ".FileDescriptor\022\013\n\003buf\030\002 \001(\014\022\r\n\005flags\030\003 "
  "\001(\005\022\025\n\002to\030\004 \001(\0132\t.SockAddr\"Y\n\nSocketpair"
  "\022\027\n\006domain\030\001 \001(\0162\007.Domain\022\025\n\004type\030\002 \001(\0162"
  "\007.SoType\022\033\n\010protocol\030\003 \001(\0162\t.Protocol\"\021\n"
  "\017NecpSessionOpen\"\213\001\n\021NecpSessionAction\022 "
  "\n\007necp_fd\030\001 \001(\0162\017.FileDescriptor\022(\n\006acti"
  "on\030\002 \001(\0162\030.NecpSessionActionNumber\022\021\n\tin"
  "_buffer\030\003 \001(\014\022\027\n\017out_buffer_size\030\004 \001(\r\"%"
  "\n\017NecpMatchPolicy\022\022\n\nparameters\030\001 \001(\014\"(\n"
  "\010NecpOpen\022\034\n\005flags\030\001 \003(\0162\r.NecpOpenFlag\""
  "\225\002\n\020NecpClientAction\022 \n\007necp_fd\030\001 \001(\0162\017."
  "FileDescriptor\022 \n\tclient_id\030\003 \001(\0162\r.Necp"
  "ClientId\022#\n\003add\030\005 \001(\0132\024.NecpClientAction"
  "AddH\000\022)\n\006remove\030\006 \001(\0132\027.NecpClientAction"
  "RemoveH\000\022:\n\017copy_parameters\030\007 \001(\0132\037.Necp"
  "ClientActionCopyParametersH\000\022\'\n\005agent\030\013 "
  "\001(\0132\026.NecpClientActionAgentH\000B\010\n\006action\""
  "%\n\023NecpClientActionAdd\022\016\n\006buffer\030\001 \001(\014\"\030"
  "\n\026NecpClientActionRemove\"6\n\036NecpClientAc"
  "tionCopyParameters\022\024\n\014copyout_size\030\001 \001(\r"
  "\"3\n\025NecpClientActionAgent\022\032\n\010necp_tlv\030\001 "
  "\003(\0132\010.NecpTlv\"*\n\007NecpTlv\022\021\n\tnecp_type\030\001 "
  "\001(\r\022\014\n\004data\030\002 \001(\014\"\n\n\010ClearAll\"$\n\005Close\022\033"
  "\n\002fd\030\001 \002(\0162\017.FileDescriptor\"B\n\006Accept\022\033\n"
  "\010sockaddr\030\001 \002(\0132\t.SockAddr\022\033\n\002fd\030\002 \001(\0162\017"
  ".FileDescriptor\"@\n\004Bind\022\033\n\010sockaddr\030\001 \002("
  "\0132\t.SockAddr\022\033\n\002fd\030\002 \001(\0162\017.FileDescripto"
  "r\":\n\006Listen\022\037\n\006socket\030\001 \002(\0162\017.FileDescri"
  "ptor\022\017\n\007backlog\030\002 \001(\005\"\206\001\n\tIoctlReal\022.\n\022s"
  "iocaifaddr_in6_64\030\001 \001(\0132\020.In6_AliasReq_6"
  "4H\000\022#\n\014siocsifflags\030\003 \001(\0132\013.IfReqFlagsH\000"
  "\022\033\n\002fd\030\002 \001(\0162\017.FileDescriptorB\007\n\005ioctl\"B"
  "\n\nIfReqFlags\022\032\n\010ifr_name\030\001 \002(\0162\010.IfrName"
  "\022\030\n\005flags\030\002 \003(\0162\t.IfruFlag\"\325\001\n\017In6_Alias"
  "Req_64\022\021\n\tifra_name\030\001 \002(\014\022\035\n\tifra_addr\030\002"
  " \002(\0132\n.SockAddr6\022 \n\014ifra_dstaddr\030\003 \002(\0132\n"
  ".SockAddr6\022#\n\017ifra_prefixmask\030\004 \002(\0132\n.So"
  "ckAddr6\022\035\n\nifra_flags\030\005 \003(\0162\t.IfraFlag\022*"
  "\n\rifra_lifetime\030\006 \002(\0132\023.In6AddrLifetime_"
  "64\"k\n\022In6AddrLifetime_64\022\023\n\013ia6t_expire\030"
  "\001 \002(\004\022\026\n\016ia6t_preferred\030\002 \002(\004\022\023\n\013ia6t_vl"
  "time\030\003 \002(\r\022\023\n\013ia6t_pltime\030\004 \002(\r\"\304\001\n\006Pack"
  "et\022 \n\ntcp_packet\030\001 \001(\0132\n.TcpPacketH\000\022\"\n\013"
  "tcp6_packet\030\002 \001(\0132\013.Tcp6PacketH\000\022 \n\nip4_"
  "packet\030\003 \001(\0132\n.Ip4PacketH\000\022 \n\nip6_packet"
  "\030\004 \001(\0132\n.Ip6PacketH\000\022\022\n\007raw_ip4\030\350\007 \001(\014H\000"
  "\022\022\n\007raw_ip6\030\351\007 \001(\014H\000B\010\n\006packet\"K\n\tTcpPac"
  "ket\022\026\n\006ip_hdr\030\001 \002(\0132\006.IpHdr\022\030\n\007tcp_hdr\030\002"
  " \002(\0132\007.TcpHdr\022\014\n\004data\030\003 \001(\014\"N\n\nTcp6Packe"
  "t\022\030\n\007ip6_hdr\030\001 \002(\0132\007.Ip6Hdr\022\030\n\007tcp_hdr\030\002"
  " \002(\0132\007.TcpHdr\022\014\n\004data\030\003 \001(\014\"1\n\tIp4Packet"
  "\022\026\n\006ip_hdr\030\001 \001(\0132\006.IpHdr\022\014\n\004data\030\002 \001(\014\"3"
  "\n\tIp6Packet\022\030\n\007ip6_hdr\030\001 \001(\0132\007.Ip6Hdr\022\014\n"
  "\004data\030\002 \001(\014\"7\n\006Ip6Ext\022\033\n\010ip6e_nxt\030\001 \002(\0162"
  "\t.Protocol\022\020\n\010ip6e_len\030\002 \002(\r\"n\n\010Ip6RtHdr"
  "\022\033\n\010ip6r_nxt\030\001 \002(\0162\t.Protocol\022\020\n\010ip6r_le"
  "n\030\002 \002(\r\022\035\n\tip6r_type\030\003 \002(\0162\n.Ip6RtType\022\024"
  "\n\014ip6r_segleft\030\004 \002(\r\"\262\001\n\tIp6Rt0Hdr\022\034\n\tip"
  "6r0_nxt\030\001 \002(\0162\t.Protocol\022\021\n\tip6r0_len\030\002 "
  "\002(\r\022\022\n\nip6r0_type\030\003 \002(\r\022\025\n\rip6r0_segleft"
  "\030\004 \002(\r\022\026\n\016ip6r0_reserved\030\005 \002(\r\022\023\n\013ip6r0_"
  "slmap\030\006 \002(\r\022\034\n\nip6r0_addr\030\007 \003(\0162\010.In6Add"
  "r\"h\n\nIp6FragHdr\022\033\n\010ip6f_nxt\030\001 \002(\0162\t.Prot"
  "ocol\022\025\n\rip6f_reserved\030\002 \002(\r\022\022\n\nip6f_offl"
  "g\030\003 \002(\r\022\022\n\nip6f_ident\030\004 \002(\r\"`\n\010Icmp6Hdr\022"
  "\036\n\nicmp6_type\030\001 \001(\0162\n.Icmp6Type\022\036\n\nicmp6"
  "_code\030\002 \001(\0162\n.Icmp6Code\022\024\n\014icmp6_dataun\030"
  "\004 \001(\r\"\362\001\n\006TcpHdr\022\027\n\010th_sport\030\001 \002(\0162\005.Por"
  "t\022\027\n\010th_dport\030\002 \002(\0162\005.Port\022\027\n\006th_seq\030\003 \002"
  "(\0162\007.TcpSeq\022\027\n\006th_ack\030\004 \002(\0162\007.TcpSeq\022\016\n\006"
  "th_off\030\005 \002(\r\022\032\n\010th_flags\030\006 \003(\0162\010.TcpFlag"
  "\022\016\n\006th_win\030\007 \002(\r\022\016\n\006th_sum\030\010 \002(\r\022\016\n\006th_u"
  "rp\030\t \002(\r\022\023\n\013is_pure_syn\030\n \002(\010\022\023\n\013is_pure"
  "_ack\030\013 \002(\010\"\312\001\n\005IpHdr\022\r\n\005ip_hl\030\001 \002(\r\022\030\n\004i"
  "p_v\030\002 \002(\0162\n.IpVersion\022\016\n\006ip_tos\030\003 \002(\r\022\016\n"
  "\006ip_len\030\004 \002(\r\022\r\n\005ip_id\030\005 \002(\r\022\016\n\006ip_off\030\006"
  " \002(\r\022\016\n\006ip_ttl\030\007 \002(\r\022\027\n\004ip_p\030\010 \002(\0162\t.Pro"
  "tocol\022\027\n\006ip_src\030\t \002(\0162\007.InAddr\022\027\n\006ip_dst"
  "\030\n \002(\0162\007.InAddr\"^\n\006Ip6Hdr\022\036\n\nip6_hdrctl\030"
  "\001 \002(\0132\n.Ip6Hdrctl\022\031\n\007ip6_src\030\002 \002(\0162\010.In6"
  "Addr\022\031\n\007ip6_dst\030\003 \002(\0162\010.In6Addr\"m\n\tIp6Hd"
  "rctl\022\024\n\014ip6_un1_flow\030\001 \002(\r\022\024\n\014ip6_un1_pl"
  "en\030\002 \002(\r\022\036\n\013ip6_un1_nxt\030\003 \002(\0162\t.Protocol"
  "\022\024\n\014ip6_un1_hlim\030\004 \002(\r\"\030\n\003Key\022\021\n\tmbuf_da"
  "ta\030\001 \002(\014\"B\n\005Ioctl\022\034\n\tioctl_idx\030\001 \002(\0162\t.I"
  "octlIdx\022\033\n\002fd\030\002 \002(\0162\017.FileDescriptor\"p\n\014"
  "SetSocketOpt\022\030\n\005level\030\001 \001(\0162\t.Protocol\022\034"
  "\n\004name\030\002 \001(\0162\016.SocketOptName\022\013\n\003val\030\003 \001("
  "\014\022\033\n\002fd\030\004 \001(\0162\017.FileDescriptor\"`\n\014GetSoc"
  "ketOpt\022\030\n\005level\030\001 \001(\0162\t.Protocol\022\034\n\004name"
  "\030\002 \001(\0162\016.SocketOptName\022\014\n\004size\030\003 \001(\005\022\n\n\002"
  "fd\030\004 \001(\r\"X\n\006Socket\022\027\n\006domain\030\001 \002(\0162\007.Dom"
  "ain\022\030\n\007so_type\030\002 \002(\0162\007.SoType\022\033\n\010protoco"
  "l\030\003 \002(\0162\t.Protocol*{\n\nSaeAssocID\022\022\n\016ASSO"
  "CID_CASE_0\020\000\022\022\n\016ASSOCID_CASE_1\020\001\022\022\n\016ASSO"
  "CID_CASE_2\020\002\022\022\n\016ASSOCID_CASE_3\020\003\022\035\n\020ASSO"
  "CID_CASE_END\020\377\377\377\377\377\377\377\377\377\001*\204\004\n\007In6Addr\022\020\n\014I"
  "N6_ADDR_ANY\020\000\022\025\n\021IN6_ADDR_LOOPBACK\020\001\022\021\n\r"
  "IN6_ADDR_REAL\020\002\022\021\n\rIN6_ADDR_SELF\020\003\022\027\n\023IN"
  "6_ADDR_LINK_LOCAL\020\004\022\030\n\024IN6_ADDR_UNSPECIF"
  "IED\020\005\022\025\n\021IN6_ADDR_V4COMPAT\020\007\022\025\n\021IN6_ADDR"
  "_V4MAPPED\020\010\022\021\n\rIN6_ADDR_6TO4\020\t\022\026\n\022IN6_AD"
  "DR_LINKLOCAL\020\n\022\026\n\022IN6_ADDR_SITELOCAL\020\013\022\026"
  "\n\022IN6_ADDR_MULTICAST\020\014\022\031\n\025IN6_ADDR_UNIQU"
  "E_LOCAL\020\r\022\031\n\025IN6_ADDR_MC_NODELOCAL\020\016\022\034\n\030"
  "IN6_ADDR_MC_INTFACELOCAL\020\017\022\031\n\025IN6_ADDR_M"
  "C_LINKLOCAL\020\020\022\031\n\025IN6_ADDR_MC_SITELOCAL\020\021"
  "\022\030\n\024IN6_ADDR_MC_ORGLOCAL\020\022\022\026\n\022IN6_ADDR_M"
  "C_GLOBAL\020\023\022\032\n\026IN6_ADDR_LOCAL_ADDRESS\020\024\022\026"
  "\n\017MAYBE_LOCALHOST\020\200\200\200\010*\232\001\n\006InAddr\022\016\n\nIN4"
  "_ADDR_0\020\000\022\016\n\nIN4_ADDR_1\020\001\022\016\n\nIN4_ADDR_2\020"
  "\002\022\022\n\nIN4_ADDR_4\020\320\365\210\304\001\022\022\n\nIN4_ADDR_5\020\201\200\200\370"
  "\007\022\027\n\nIN4_ADDR_6\020\330\254\241\205\374\377\377\377\377\001\022\037\n\022IN4_ADDR_B"
  "ROADCAST\020\377\377\377\377\377\377\377\377\377\001*N\n\010FlowInfo\022\017\n\013FLOW_"
  "INFO_0\020\000\022\017\n\013FLOW_INFO_1\020\001\022\017\n\013FLOW_INFO_2"
  "\020\002\022\017\n\013FLOW_INFO_3\020\003*Z\n\007ScopeId\022\016\n\nSCOPE_"
  "ID_0\020\000\022\016\n\nSCOPE_ID_1\020\001\022\016\n\nSCOPE_ID_2\020\002\022\016"
  "\n\nSCOPE_ID_3\020\003\022\017\n\013SCOPE_ID_50\0202*L\n\004Port\022"
  "\n\n\006PORT_0\020\000\022\n\n\006PORT_1\020\001\022\n\n\006PORT_2\020\002\022\016\n\tP"
  "ORT_5555\020\263+\022\020\n\nPORT_65000\020\350\373\003*O\n\005IfIdx\022\020"
  "\n\014IFIDX_CASE_0\020\000\022\020\n\014IFIDX_CASE_1\020\001\022\020\n\014IF"
  "IDX_CASE_2\020\002\022\020\n\014IFIDX_CASE_3\020\003*m\n\014Connec"
  "tXFlag\022 \n\034CONNECT_RESUME_ON_READ_WRITE\020\001"
  "\022\033\n\027CONNECT_DATA_IDEMPOTENT\020\002\022\036\n\032CONNECT"
  "_DATA_AUTHENTICATED\020\004*6\n\013ShutdownHow\022\013\n\007"
  "SHUT_RD\020\000\022\013\n\007SHUT_WR\020\001\022\r\n\tSHUT_RDWR\020\002*l\n"
  "\014NecpOpenFlag\022\033\n\027NECP_OPEN_FLAG_OBSERVER"
  "\020\001\022\035\n\031NECP_OPEN_FLAG_BACKGROUND\020\002\022 \n\034NEC"
  "P_OPEN_FLAG_PUSH_OBSERVER\020\004*8\n\014NecpClien"
  "tId\022\014\n\010CLIENT_0\020\000\022\014\n\010CLIENT_1\020\001\022\014\n\010CLIEN"
  "T_2\020\002*\264\005\n\026NecpClientActionNumber\022\032\n\026NECP"
  "_CLIENT_ACTION_ADD\020\001\022\035\n\031NECP_CLIENT_ACTI"
  "ON_REMOVE\020\002\022&\n\"NECP_CLIENT_ACTION_COPY_P"
  "ARAMETERS\020\003\022\"\n\036NECP_CLIENT_ACTION_COPY_R"
  "ESULT\020\004\022 \n\034NECP_CLIENT_ACTION_COPY_LIST\020"
  "\005\022-\n)NECP_CLIENT_ACTION_REQUEST_NEXUS_IN"
  "STANCE\020\006\022\034\n\030NECP_CLIENT_ACTION_AGENT\020\007\022!"
  "\n\035NECP_CLIENT_ACTION_COPY_AGENT\020\010\022%\n!NEC"
  "P_CLIENT_ACTION_COPY_INTERFACE\020\t\022%\n!NECP"
  "_CLIENT_ACTION_SET_STATISTICS\020\n\022,\n(NECP_"
  "CLIENT_ACTION_COPY_ROUTE_STATISTICS\020\013\022 \n"
  "\034NECP_CLIENT_ACTION_AGENT_USE\020\014\022\"\n\036NECP_"
  "CLIENT_ACTION_MAP_SYSCTLS\020\r\022#\n\037NECP_CLIE"
  "NT_ACTION_UPDATE_CACHE\020\016\022)\n%NECP_CLIENT_"
  "ACTION_COPY_CLIENT_UPDATE\020\017\022*\n&NECP_CLIE"
  "NT_ACTION_COPY_UPDATED_RESULT\020\020\022\037\n\033NECP_"
  "CLIENT_ACTION_ADD_FLOW\020\021\022\"\n\036NECP_CLIENT_"
  "ACTION_REMOVE_FLOW\020\022*\341\003\n\027NecpSessionActi"
  "onNumber\022\"\n\036NECP_SESSION_ACTION_POLICY_A"
  "DD\020\001\022\"\n\036NECP_SESSION_ACTION_POLICY_GET\020\002"
  "\022%\n!NECP_SESSION_ACTION_POLICY_DELETE\020\003\022"
  "(\n$NECP_SESSION_ACTION_POLICY_APPLY_ALL\020"
  "\004\022\'\n#NECP_SESSION_ACTION_POLICY_LIST_ALL"
  "\020\005\022)\n%NECP_SESSION_ACTION_POLICY_DELETE_"
  "ALL\020\006\022,\n(NECP_SESSION_ACTION_SET_SESSION"
  "_PRIORITY\020\007\022,\n(NECP_SESSION_ACTION_LOCK_"
  "SESSION_TO_PROC\020\010\022(\n$NECP_SESSION_ACTION"
  "_REGISTER_SERVICE\020\t\022*\n&NECP_SESSION_ACTI"
  "ON_UNREGISTER_SERVICE\020\n\022\'\n#NECP_SESSION_"
  "ACTION_POLICY_DUMP_ALL\020\013*\034\n\007IfrName\022\007\n\003L"
  "O0\020\000\022\010\n\004STF0\020\001*\243\002\n\010IfruFlag\022\n\n\006IFF_UP\020\001\022"
  "\021\n\rIFF_BROADCAST\020\002\022\r\n\tIFF_DEBUG\020\004\022\020\n\014IFF"
  "_LOOPBACK\020\010\022\023\n\017IFF_POINTOPOINT\020\020\022\022\n\016IFF_"
  "NOTRAILERS\020 \022\017\n\013IFF_RUNNING\020@\022\016\n\tIFF_NOA"
  "RP\020\200\001\022\020\n\013IFF_PROMISC\020\200\002\022\021\n\014IFF_ALLMULTI\020"
  "\200\004\022\020\n\013IFF_OACTIVE\020\200\010\022\020\n\013IFF_SIMPLEX\020\200\020\022\016"
  "\n\tIFF_LINK0\020\200 \022\016\n\tIFF_LINK1\020\200@\022\017\n\tIFF_LI"
  "NK2\020\200\200\001\022\023\n\rIFF_MULTICAST\020\200\200\002*\303\002\n\010IfraFla"
  "g\022\023\n\017IN6_IFF_ANYCAST\020\001\022\025\n\021IN6_IFF_TENTAT"
  "IVE\020\002\022\026\n\022IN6_IFF_DUPLICATED\020\004\022\024\n\020IN6_IFF"
  "_DETACHED\020\010\022\026\n\022IN6_IFF_DEPRECATED\020\020\022\021\n\rI"
  "N6_IFF_NODAD\020 \022\024\n\020IN6_IFF_AUTOCONF\020@\022\026\n\021"
  "IN6_IFF_TEMPORARY\020\200\001\022\024\n\017IN6_IFF_DYNAMIC\020"
  "\200\002\022\027\n\022IN6_IFF_OPTIMISTIC\020\200\004\022\024\n\017IN6_IFF_S"
  "ECURED\020\200\010\022\025\n\020IN6_IFF_SWIFTDAD\020\200\020\022\023\n\016IN6_"
  "IFF_CLAT46\020\200 \022\023\n\rIN6_IFF_NOPFX\020\200\200\002*\"\n\tIp"
  "6RtType\022\025\n\021IPV6_RTHDR_TYPE_0\020\000*\350\003\n\tIcmp6"
  "Type\022\025\n\021ICMP6_DST_UNREACH\020\001\022\030\n\024ICMP6_PAC"
  "KET_TOO_BIG\020\002\022\027\n\023ICMP6_TIME_EXCEEDED\020\003\022\024"
  "\n\020ICMP6_PARAM_PROB\020\004\022\027\n\022ICMP6_ECHO_REQUE"
  "ST\020\200\001\022\025\n\020ICMP6_ECHO_REPLY\020\201\001\022\027\n\022MLD_LIST"
  "ENER_QUERY\020\202\001\022\030\n\023MLD_LISTENER_REPORT\020\203\001\022"
  "\026\n\021MLD_LISTENER_DONE\020\204\001\022\026\n\021ND_ROUTER_SOL"
  "ICIT\020\205\001\022\025\n\020ND_ROUTER_ADVERT\020\206\001\022\030\n\023ND_NEI"
  "GHBOR_SOLICIT\020\207\001\022\027\n\022ND_NEIGHBOR_ADVERT\020\210"
  "\001\022\020\n\013ND_REDIRECT\020\211\001\022\035\n\030ICMP6_ROUTER_RENU"
  "MBERING\020\212\001\022\025\n\020ICMP6_WRUREQUEST\020\213\001\022\023\n\016ICM"
  "P6_WRUREPLY\020\214\001\022\032\n\025MLDV2_LISTENER_REPORT\020"
  "\217\001\022\024\n\017MLD_MTRACE_RESP\020\310\001\022\017\n\nMLD_MTRACE\020\311"
  "\001*\351\001\n\tIcmp6Code\022\035\n\031ICMP6_DST_UNREACH_NOR"
  "OUTE\020\000\022\033\n\027ICMP6_DST_UNREACH_ADMIN\020\001\022!\n\035I"
  "CMP6_DST_UNREACH_NOTNEIGHBOR\020\002\022\032\n\026ICMP6_"
  "DST_UNREACH_ADDR\020\003\022\034\n\030ICMP6_DST_UNREACH_"
  "NOPORT\020\004\022\027\n\022ICMP6_INFOMSG_MASK\020\200\001\022*\n%ICM"
  "P6_ROUTER_RENUMBERING_SEQNUM_RESET\020\377\001*`\n"
  "\006TcpSeq\022\t\n\005SEQ_1\020\001\022\t\n\005SEQ_2\020\002\022\t\n\005SEQ_3\020\003"
  "\022\t\n\005SEQ_4\020\004\022\t\n\005SEQ_5\020\005\022\t\n\005SEQ_6\020\006\022\t\n\005SEQ"
  "_7\020\007\022\t\n\005SEQ_8\020\010*k\n\007TcpFlag\022\n\n\006TH_FIN\020\001\022\n"
  "\n\006TH_SYN\020\002\022\n\n\006TH_RST\020\004\022\013\n\007TH_PUSH\020\010\022\n\n\006T"
  "H_ACK\020\020\022\n\n\006TH_URG\020 \022\n\n\006TH_ECE\020@\022\013\n\006TH_CW"
  "R\020\200\001*\037\n\tIpVersion\022\010\n\004IPV4\020\004\022\010\n\004IPV6\020\006*\357."
  "\n\010IoctlIdx\022\016\n\nSIOCSHIWAT\020\001\022\016\n\nSIOCGHIWAT"
  "\020\002\022\016\n\nSIOCSLOWAT\020\003\022\016\n\nSIOCGLOWAT\020\004\022\016\n\nSI"
  "OCATMARK\020\005\022\r\n\tSIOCSPGRP\020\006\022\r\n\tSIOCGPGRP\020\007"
  "\022\017\n\013SIOCSIFADDR\020\010\022\020\n\014OSIOCGIFADDR\020\t\022\022\n\016S"
  "IOCSIFDSTADDR\020\n\022\023\n\017OSIOCGIFDSTADDR\020\013\022\020\n\014"
  "SIOCSIFFLAGS\020\014\022\020\n\014SIOCGIFFLAGS\020\r\022\023\n\017OSIO"
  "CGIFBRDADDR\020\016\022\022\n\016SIOCSIFBRDADDR\020\017\022\020\n\014OSI"
  "OCGIFCONF\020\020\022\022\n\016OSIOCGIFCONF32\020\021\022\022\n\016OSIOC"
  "GIFCONF64\020\022\022\023\n\017OSIOCGIFNETMASK\020\023\022\022\n\016SIOC"
  "SIFNETMASK\020\024\022\021\n\rSIOCGIFMETRIC\020\025\022\021\n\rSIOCS"
  "IFMETRIC\020\026\022\017\n\013SIOCDIFADDR\020\027\022\017\n\013SIOCAIFAD"
  "DR\020\030\022\017\n\013SIOCGIFADDR\020\031\022\022\n\016SIOCGIFDSTADDR\020"
  "\032\022\022\n\016SIOCGIFBRDADDR\020\033\022\017\n\013SIOCGIFCONF\020\034\022\021"
  "\n\rSIOCGIFCONF32\020\035\022\021\n\rSIOCGIFCONF64\020\036\022\022\n\016"
  "SIOCGIFNETMASK\020\037\022\020\n\014SIOCADDMULTI\020 \022\020\n\014SI"
  "OCDELMULTI\020!\022\016\n\nSIOCGIFMTU\020\"\022\016\n\nSIOCSIFM"
  "TU\020#\022\017\n\013SIOCGIFPHYS\020$\022\017\n\013SIOCSIFPHYS\020%\022\020"
  "\n\014SIOCSIFMEDIA\020&\022\020\n\014SIOCGIFMEDIA\020\'\022\022\n\016SI"
  "OCGIFMEDIA32\020(\022\022\n\016SIOCGIFMEDIA64\020)\022\022\n\016SI"
  "OCSIFGENERIC\020*\022\022\n\016SIOCGIFGENERIC\020+\022\021\n\rSI"
  "OCSIFLLADDR\020,\022\021\n\rSIOCGIFSTATUS\020-\022\022\n\016SIOC"
  "SIFPHYADDR\020.\022\023\n\017SIOCGIFPSRCADDR\020/\022\023\n\017SIO"
  "CGIFPDSTADDR\0200\022\022\n\016SIOCDIFPHYADDR\0201\022\021\n\rSI"
  "OCGIFDEVMTU\0202\022\021\n\rSIOCSIFALTMTU\0203\022\023\n\017SIOC"
  "PROTOATTACH\0204\022\023\n\017SIOCPROTODETACH\0205\022\020\n\014SI"
  "OCIFCREATE\0206\022\021\n\rSIOCIFDESTROY\0207\022\017\n\013SIOCS"
  "IFVLAN\0208\022\017\n\013SIOCGIFVLAN\0209\022\017\n\013SIOCSETVLAN"
  "\020:\022\017\n\013SIOCGETVLAN\020;\022\021\n\rSIOCSIFDEVMTU\020<\022\022"
  "\n\016SIOCIFGCLONERS\020=\022\024\n\020SIOCIFGCLONERS32\020>"
  "\022\024\n\020SIOCIFGCLONERS64\020\?\022\023\n\017SIOCGIFASYNCMA"
  "P\020@\022\023\n\017SIOCSIFASYNCMAP\020A\022\016\n\nSIOCSIFKPI\020B"
  "\022\016\n\nSIOCGIFKPI\020C\022\024\n\020SIOCGIFWAKEFLAGS\020D\022\026"
  "\n\022SIOCGIFGETRTREFCNT\020E\022\034\n\030SIOCGIFLINKQUA"
  "LITYMETRIC\020F\022\025\n\021SIOCSETROUTERMODE\020G\022\021\n\rS"
  "IOCGIFEFLAGS\020H\022\017\n\013SIOCSIFDESC\020I\022\017\n\013SIOCG"
  "IFDESC\020J\022\025\n\021SIOCSIFLINKPARAMS\020K\022\025\n\021SIOCG"
  "IFLINKPARAMS\020L\022\025\n\021SIOCGIFQUEUESTATS\020M\022\023\n"
  "\017SIOCSIFTHROTTLE\020N\022\023\n\017SIOCGIFTHROTTLE\020O\022"
  "\021\n\rSIOCGASSOCIDS\020P\022\020\n\014SIOCGCONNIDS\020Q\022\021\n\r"
  "SIOCGCONNINFO\020R\022\023\n\017SIOCGASSOCIDS32\020S\022\023\n\017"
  "SIOCGASSOCIDS64\020T\022\022\n\016SIOCGCONNIDS32\020U\022\022\n"
  "\016SIOCGCONNIDS64\020V\022\023\n\017SIOCGCONNINFO32\020W\022\023"
  "\n\017SIOCGCONNINFO64\020X\022\022\n\016SIOCSCONNORDER\020Y\022"
  "\022\n\016SIOCGCONNORDER\020Z\022\016\n\nSIOCSIFLOG\020[\022\016\n\nS"
  "IOCGIFLOG\020\\\022\023\n\017SIOCGIFDELEGATE\020]\022\021\n\rSIOC"
  "GIFLLADDR\020^\022\017\n\013SIOCGIFTYPE\020_\022\024\n\020SIOCGIFE"
  "XPENSIVE\020`\022\024\n\020SIOCSIFEXPENSIVE\020a\022\017\n\013SIOC"
  "GIF2KCL\020b\022\017\n\013SIOCSIF2KCL\020c\022\023\n\017SIOCGSTART"
  "DELAY\020d\022\022\n\016SIOCAIFAGENTID\020e\022\022\n\016SIOCDIFAG"
  "ENTID\020f\022\023\n\017SIOCGIFAGENTIDS\020g\022\024\n\020SIOCGIFA"
  "GENTDATA\020h\022\025\n\021SIOCGIFAGENTIDS32\020i\022\025\n\021SIO"
  "CGIFAGENTIDS64\020j\022\026\n\022SIOCGIFAGENTDATA32\020k"
  "\022\026\n\022SIOCGIFAGENTDATA64\020l\022\031\n\025SIOCSIFINTER"
  "FACESTATE\020m\022\031\n\025SIOCGIFINTERFACESTATE\020n\022\034"
  "\n\030SIOCSIFPROBECONNECTIVITY\020o\022\034\n\030SIOCGIFP"
  "ROBECONNECTIVITY\020p\022\031\n\025SIOCGIFFUNCTIONALT"
  "YPE\020q\022\027\n\023SIOCSIFNETSIGNATURE\020r\022\027\n\023SIOCGI"
  "FNETSIGNATURE\020s\022\020\n\014SIOCGECNMODE\020t\022\020\n\014SIO"
  "CSECNMODE\020u\022\020\n\014SIOCSIFORDER\020v\022\020\n\014SIOCGIF"
  "ORDER\020w\022\027\n\023SIOCSQOSMARKINGMODE\020x\022\030\n\024SIOC"
  "SFASTLANECAPABLE\020y\022\032\n\026SIOCSQOSMARKINGENA"
  "BLED\020z\022\026\n\022SIOCSFASTLEENABLED\020{\022\027\n\023SIOCGQ"
  "OSMARKINGMODE\020|\022\032\n\026SIOCGQOSMARKINGENABLE"
  "D\020}\022\032\n\026SIOCSIFTIMESTAMPENABLE\020~\022\033\n\027SIOCS"
  "IFTIMESTAMPDISABLE\020\177\022\034\n\027SIOCGIFTIMESTAMP"
  "ENABLED\020\200\001\022\031\n\024SIOCSIFDISABLEOUTPUT\020\201\001\022\025\n"
  "\020SIOCGIFAGENTLIST\020\202\001\022\027\n\022SIOCGIFAGENTLIST"
  "32\020\203\001\022\027\n\022SIOCGIFAGENTLIST64\020\204\001\022\027\n\022SIOCSI"
  "FLOWINTERNET\020\205\001\022\027\n\022SIOCGIFLOWINTERNET\020\206\001"
  "\022\027\n\022SIOCGIFNAT64PREFIX\020\207\001\022\027\n\022SIOCSIFNAT6"
  "4PREFIX\020\210\001\022\021\n\014SIOCGIFNEXUS\020\211\001\022\024\n\017SIOCSIF"
  "ADDR_IN6\020\212\001\022\024\n\017SIOCGIFADDR_IN6\020\213\001\022\027\n\022SIO"
  "CSIFDSTADDR_IN6\020\214\001\022\027\n\022SIOCSIFNETMASK_IN6"
  "\020\215\001\022\027\n\022SIOCGIFDSTADDR_IN6\020\216\001\022\027\n\022SIOCGIFN"
  "ETMASK_IN6\020\217\001\022\024\n\017SIOCDIFADDR_IN6\020\220\001\022\024\n\017S"
  "IOCAIFADDR_IN6\020\221\001\022\027\n\022SIOCAIFADDR_IN6_32\020"
  "\222\001\022\027\n\022SIOCAIFADDR_IN6_64\020\223\001\022\027\n\022SIOCSIFPH"
  "YADDR_IN6\020\224\001\022\032\n\025SIOCSIFPHYADDR_IN6_32\020\225\001"
  "\022\032\n\025SIOCSIFPHYADDR_IN6_64\020\226\001\022\030\n\023SIOCGIFP"
  "SRCADDR_IN6\020\227\001\022\030\n\023SIOCGIFPDSTADDR_IN6\020\230\001"
  "\022\025\n\020SIOCGIFAFLAG_IN6\020\231\001\022\023\n\016SIOCGDRLST_IN"
  "6\020\232\001\022\026\n\021SIOCGDRLST_IN6_32\020\233\001\022\026\n\021SIOCGDRL"
  "ST_IN6_64\020\234\001\022\023\n\016SIOCGPRLST_IN6\020\235\001\022\026\n\021SIO"
  "CGPRLST_IN6_32\020\236\001\022\026\n\021SIOCGPRLST_IN6_64\020\237"
  "\001\022\025\n\020OSIOCGIFINFO_IN6\020\240\001\022\024\n\017SIOCGIFINFO_"
  "IN6\020\241\001\022\025\n\020SIOCSNDFLUSH_IN6\020\242\001\022\025\n\020SIOCGNB"
  "RINFO_IN6\020\243\001\022\030\n\023SIOCGNBRINFO_IN6_32\020\244\001\022\030"
  "\n\023SIOCGNBRINFO_IN6_64\020\245\001\022\026\n\021SIOCSPFXFLUS"
  "H_IN6\020\246\001\022\026\n\021SIOCSRTRFLUSH_IN6\020\247\001\022\031\n\024SIOC"
  "GIFALIFETIME_IN6\020\250\001\022\031\n\024SIOCSIFALIFETIME_"
  "IN6\020\251\001\022\024\n\017SIOCGIFSTAT_IN6\020\252\001\022\026\n\021SIOCGIFS"
  "TAT_ICMP6\020\253\001\022\026\n\021SIOCSDEFIFACE_IN6\020\254\001\022\026\n\021"
  "SIOCGDEFIFACE_IN6\020\255\001\022\031\n\024SIOCSDEFIFACE_IN"
  "6_32\020\256\001\022\031\n\024SIOCSDEFIFACE_IN6_64\020\257\001\022\031\n\024SI"
  "OCGDEFIFACE_IN6_32\020\260\001\022\031\n\024SIOCGDEFIFACE_I"
  "N6_64\020\261\001\022\026\n\021SIOCSIFINFO_FLAGS\020\262\001\022\020\n\013SIOC"
  "SSCOPE6\020\263\001\022\020\n\013SIOCGSCOPE6\020\264\001\022\023\n\016SIOCGSCO"
  "PE6DEF\020\265\001\022\026\n\021SIOCSIFPREFIX_IN6\020\266\001\022\026\n\021SIO"
  "CGIFPREFIX_IN6\020\267\001\022\026\n\021SIOCDIFPREFIX_IN6\020\270"
  "\001\022\026\n\021SIOCAIFPREFIX_IN6\020\271\001\022\026\n\021SIOCCIFPREF"
  "IX_IN6\020\272\001\022\027\n\022SIOCSGIFPREFIX_IN6\020\273\001\022\030\n\023SI"
  "OCAADDRCTL_POLICY\020\274\001\022\030\n\023SIOCDADDRCTL_POL"
  "ICY\020\275\001\022\030\n\023SIOCPROTOATTACH_IN6\020\276\001\022\033\n\026SIOC"
  "PROTOATTACH_IN6_32\020\277\001\022\033\n\026SIOCPROTOATTACH"
  "_IN6_64\020\300\001\022\030\n\023SIOCPROTODETACH_IN6\020\301\001\022\021\n\014"
  "SIOCLL_START\020\302\001\022\024\n\017SIOCLL_START_32\020\303\001\022\024\n"
  "\017SIOCLL_START_64\020\304\001\022\020\n\013SIOCLL_STOP\020\305\001\022\027\n"
  "\022SIOCAUTOCONF_START\020\306\001\022\026\n\021SIOCAUTOCONF_S"
  "TOP\020\307\001\022\022\n\rSIOCDRADD_IN6\020\310\001\022\025\n\020SIOCDRADD_"
  "IN6_32\020\311\001\022\025\n\020SIOCDRADD_IN6_64\020\312\001\022\022\n\rSIOC"
  "DRDEL_IN6\020\313\001\022\025\n\020SIOCDRDEL_IN6_32\020\314\001\022\025\n\020S"
  "IOCDRDEL_IN6_64\020\315\001\022\032\n\025SIOCSETROUTERMODE_"
  "IN6\020\316\001\022\024\n\017SIOCLL_CGASTART\020\317\001\022\027\n\022SIOCLL_C"
  "GASTART_32\020\320\001\022\027\n\022SIOCLL_CGASTART_64\020\321\001\022\027"
  "\n\022SIOCGIFCGAPREP_IN6\020\322\001\022\027\n\022SIOCSIFCGAPRE"
  "P_IN6\020\323\001\022\016\n\tDIOCSTART\020\324\001\022\r\n\010DIOCSTOP\020\325\001\022"
  "\020\n\013DIOCADDRULE\020\326\001\022\024\n\017DIOCGETSTARTERS\020\327\001\022"
  "\021\n\014DIOCGETRULES\020\330\001\022\020\n\013DIOCGETRULE\020\331\001\022\021\n\014"
  "DIOCSTARTREF\020\332\001\022\020\n\013DIOCSTOPREF\020\333\001\022\022\n\rDIO"
  "CCLRSTATES\020\334\001\022\021\n\014DIOCGETSTATE\020\335\001\022\024\n\017DIOC"
  "SETSTATUSIF\020\336\001\022\022\n\rDIOCGETSTATUS\020\337\001\022\022\n\rDI"
  "OCCLRSTATUS\020\340\001\022\020\n\013DIOCNATLOOK\020\341\001\022\021\n\014DIOC"
  "SETDEBUG\020\342\001\022\022\n\rDIOCGETSTATES\020\343\001\022\023\n\016DIOCC"
  "HANGERULE\020\344\001\022\023\n\016DIOCINSERTRULE\020\345\001\022\023\n\016DIO"
  "CDELETERULE\020\346\001\022\023\n\016DIOCSETTIMEOUT\020\347\001\022\023\n\016D"
  "IOCGETTIMEOUT\020\350\001\022\021\n\014DIOCADDSTATE\020\351\001\022\024\n\017D"
  "IOCCLRRULECTRS\020\352\001\022\021\n\014DIOCGETLIMIT\020\353\001\022\021\n\014"
  "DIOCSETLIMIT\020\354\001\022\023\n\016DIOCKILLSTATES\020\355\001\022\022\n\r"
  "DIOCSTARTALTQ\020\356\001\022\021\n\014DIOCSTOPALTQ\020\357\001\022\020\n\013D"
  "IOCADDALTQ\020\360\001\022\021\n\014DIOCGETALTQS\020\361\001\022\020\n\013DIOC"
  "GETALTQ\020\362\001\022\023\n\016DIOCCHANGEALTQ\020\363\001\022\022\n\rDIOCG"
  "ETQSTATS\020\364\001\022\023\n\016DIOCBEGINADDRS\020\365\001\022\020\n\013DIOC"
  "ADDADDR\020\366\001\022\021\n\014DIOCGETADDRS\020\367\001\022\020\n\013DIOCGET"
  "ADDR\020\370\001\022\023\n\016DIOCCHANGEADDR\020\371\001\022\024\n\017DIOCGETR"
  "ULESETS\020\372\001\022\023\n\016DIOCGETRULESET\020\373\001\022\023\n\016DIOCR"
  "CLRTABLES\020\374\001\022\023\n\016DIOCRADDTABLES\020\375\001\022\023\n\016DIO"
  "CRDELTABLES\020\376\001\022\023\n\016DIOCRGETTABLES\020\377\001\022\023\n\016D"
  "IOCRGETTSTATS\020\200\002\022\023\n\016DIOCRCLRTSTATS\020\201\002\022\022\n"
  "\rDIOCRCLRADDRS\020\202\002\022\022\n\rDIOCRADDADDRS\020\203\002\022\022\n"
  "\rDIOCRDELADDRS\020\204\002\022\022\n\rDIOCRSETADDRS\020\205\002\022\022\n"
  "\rDIOCRGETADDRS\020\206\002\022\023\n\016DIOCRGETASTATS\020\207\002\022\023"
  "\n\016DIOCRCLRASTATS\020\210\002\022\022\n\rDIOCRTSTADDRS\020\211\002\022"
  "\023\n\016DIOCRSETTFLAGS\020\212\002\022\023\n\016DIOCRINADEFINE\020\213"
  "\002\022\022\n\rDIOCOSFPFLUSH\020\214\002\022\020\n\013DIOCOSFPADD\020\215\002\022"
  "\020\n\013DIOCOSFPGET\020\216\002\022\017\n\nDIOCXBEGIN\020\217\002\022\020\n\013DI"
  "OCXCOMMIT\020\220\002\022\022\n\rDIOCXROLLBACK\020\221\002\022\024\n\017DIOC"
  "GETSRCNODES\020\222\002\022\024\n\017DIOCCLRSRCNODES\020\223\002\022\022\n\r"
  "DIOCSETHOSTID\020\224\002\022\023\n\016DIOCIGETIFACES\020\225\002\022\022\n"
  "\rDIOCSETIFFLAG\020\226\002\022\022\n\rDIOCCLRIFFLAG\020\227\002\022\025\n"
  "\020DIOCKILLSRCNODES\020\230\002\022\021\n\014DIOCGIFSPEED\020\231\002*"
  "\265B\n\rSocketOptName\022\014\n\010SO_DEBUG\020\001\022\021\n\rSO_AC"
  "CEPTCONN\020\002\022\020\n\014SO_REUSEADDR\020\004\022\020\n\014SO_KEEPA"
  "LIVE\020\010\022\020\n\014SO_DONTROUTE\020\020\022\020\n\014SO_BROADCAST"
  "\020 \022\022\n\016SO_USELOOPBACK\020@\022\016\n\tSO_LINGER\020\200\001\022\021"
  "\n\014SO_OOBINLINE\020\200\002\022\021\n\014SO_REUSEPORT\020\200\004\022\021\n\014"
  "SO_TIMESTAMP\020\200\010\022\033\n\026SO_TIMESTAMP_MONOTONI"
  "C\020\200\020\022\024\n\017SO_ACCEPTFILTER\020\200 \022\021\n\014SO_DONTTRU"
  "NC\020\200@\022\021\n\013SO_WANTMORE\020\200\200\001\022\024\n\016SO_WANTOOBFL"
  "AG\020\200\200\002\022\030\n\022SO_NOWAKEFROMSLEEP\020\200\200\004\022\024\n\016SO_N"
  "OAPNFALLBK\020\200\200\010\022\035\n\027SO_TIMESTAMP_CONTINUOU"
  "S\020\200\200\020\022\016\n\tSO_SNDBUF\020\201 \022\016\n\tSO_RCVBUF\020\202 \022\020\n"
  "\013SO_SNDLOWAT\020\203 \022\020\n\013SO_RCVLOWAT\020\204 \022\020\n\013SO_"
  "SNDTIMEO\020\205 \022\020\n\013SO_RCVTIMEO\020\206 \022\r\n\010SO_ERRO"
  "R\020\207 \022\014\n\007SO_TYPE\020\210 \022\r\n\010SO_LABEL\020\220 \022\021\n\014SO_"
  "PEERLABEL\020\221 \022\r\n\010SO_NREAD\020\240 \022\013\n\006SO_NKE\020\241 "
  "\022\021\n\014SO_NOSIGPIPE\020\242 \022\021\n\014SO_NOADDRERR\020\243 \022\016"
  "\n\tSO_NWRITE\020\244 \022\025\n\020SO_REUSESHAREUID\020\245 \022\026\n"
  "\021SO_NOTIFYCONFLICT\020\246 \022\027\n\022SO_UPCALLCLOSEW"
  "AIT\020\247 \022\022\n\rSO_LINGER_SEC\020\200!\022\024\n\017SO_RESTRIC"
  "TIONS\020\201!\022\022\n\rSO_RANDOMPORT\020\202!\022\025\n\020SO_NP_EX"
  "TENSIONS\020\203!\022\020\n\013SO_EXECPATH\020\205!\022\025\n\020SO_TRAF"
  "FIC_CLASS\020\206!\022\020\n\014SO_TC_BK_SYS\020d\022\r\n\010SO_TC_"
  "BK\020\310\001\022\014\n\010SO_TC_BE\020\000\022\r\n\010SO_TC_RD\020\254\002\022\016\n\tSO"
  "_TC_OAM\020\220\003\022\r\n\010SO_TC_AV\020\364\003\022\r\n\010SO_TC_RV\020\330\004"
  "\022\r\n\010SO_TC_VI\020\274\005\022\r\n\010SO_TC_VO\020\240\006\022\016\n\tSO_TC_"
  "CTL\020\204\007\022\r\n\tSO_TC_MAX\020\n\022\031\n\014SO_TC_UNSPEC\020\377\377"
  "\377\377\377\377\377\377\377\001\022\032\n\025SO_RECV_TRAFFIC_CLASS\020\207!\022\031\n\024"
  "SO_TRAFFIC_CLASS_DBG\020\210!\022\033\n\026SO_TRAFFIC_CL"
  "ASS_STATS\020\211!\022 \n\033SO_PRIVILEGED_TRAFFIC_CL"
  "ASS\020\220!\022\021\n\014SO_DEFUNCTIT\020\221!\022\021\n\014SO_DEFUNCTO"
  "K\020\200\"\022\021\n\014SO_ISDEFUNCT\020\201\"\022\025\n\020SO_OPPORTUNIS"
  "TIC\020\202\"\022\r\n\010SO_FLUSH\020\203\"\022\022\n\rSO_RECV_ANYIF\020\204"
  "\"\022\036\n\031SO_TRAFFIC_MGT_BACKGROUND\020\205\"\022\031\n\024SO_"
  "FLOW_DIVERT_TOKEN\020\206\"\022\021\n\014SO_DELEGATED\020\207\"\022"
  "\026\n\021SO_DELEGATED_UUID\020\210\"\022\027\n\022SO_NECP_ATTRI"
  "BUTES\020\211\"\022\024\n\017SO_CFIL_SOCK_ID\020\220\"\022\027\n\022SO_NEC"
  "P_CLIENTUUID\020\221\"\022\021\n\014SO_NUMRCVPKT\020\222\"\022\031\n\024SO"
  "_AWDL_UNRESTRICTED\020\223\"\022\030\n\023SO_EXTENDED_BK_"
  "IDLE\020\224\"\022\031\n\024SO_MARK_CELLFALLBACK\020\225\"\022\030\n\023SO"
  "_NET_SERVICE_TYPE\020\226\"\022\"\n\035SO_QOSMARKING_PO"
  "LICY_OVERRIDE\020\227\"\022\027\n\022SO_INTCOPROC_ALLOW\020\230"
  "\"\022\035\n\030SO_TC_NET_SERVICE_OFFSET\020\220N\022\034\n\027SO_N"
  "ETSVC_MARKING_LEVEL\020\231\"\022\016\n\nTCPOPT_EOL\020\000\022\016"
  "\n\nTCPOPT_NOP\020\001\022\021\n\rTCPOPT_MAXSEG\020\002\022\022\n\016TCP"
  "OLEN_MAXSEG\020\004\022\021\n\rTCPOPT_WINDOW\020\003\022\022\n\016TCPO"
  "LEN_WINDOW\020\003\022\031\n\025TCPOPT_SACK_PERMITTED\020\004\022"
  "\032\n\026TCPOLEN_SACK_PERMITTED\020\002\022\017\n\013TCPOPT_SA"
  "CK\020\005\022\020\n\014TCPOLEN_SACK\020\010\022\024\n\020TCPOPT_TIMESTA"
  "MP\020\010\022\025\n\021TCPOLEN_TIMESTAMP\020\n\022\021\n\rMAX_TCPOP"
  "TLEN\020(\022\r\n\tTCPOPT_CC\020\013\022\020\n\014TCPOPT_CCNEW\020\014\022"
  "\021\n\rTCPOPT_CCECHO\020\r\022\016\n\nTCPOLEN_CC\020\006\022\024\n\020TC"
  "POPT_SIGNATURE\020\023\022\025\n\021TCPOLEN_SIGNATURE\020\022\022"
  "\024\n\020TCPOPT_MULTIPATH\020\036\022\023\n\017TCPOPT_FASTOPEN"
  "\020\"\022\030\n\024TCPOLEN_FASTOPEN_REQ\020\002\022\021\n\rMAX_SACK"
  "_BLKS\020\006\022\020\n\014TCP_MAX_SACK\020\004\022\014\n\007TCP_MSS\020\200\004\022"
  "\017\n\nTCP_MINMSS\020\330\001\022\r\n\010TCP6_MSS\020\200\010\022\020\n\nTCP_M"
  "AXWIN\020\377\377\003\022\030\n\023TTCP_CLIENT_SND_WND\020\200 \022\024\n\020T"
  "CP_MAX_WINSHIFT\020\016\022\017\n\013TCP_NODELAY\020\001\022\016\n\nTC"
  "P_MAXSEG\020\002\022\016\n\nTCP_NOPUSH\020\004\022\r\n\tTCP_NOOPT\020"
  "\010\022\021\n\rTCP_KEEPALIVE\020\020\022\031\n\025TCP_CONNECTIONTI"
  "MEOUT\020 \022\023\n\017PERSIST_TIMEOUT\020@\022\031\n\024TCP_RXT_"
  "CONNDROPTIME\020\200\001\022\024\n\017TCP_RXT_FINDROP\020\200\002\022\022\n"
  "\rTCP_KEEPINTVL\020\201\002\022\020\n\013TCP_KEEPCNT\020\202\002\022\025\n\020T"
  "CP_SENDMOREACKS\020\203\002\022\023\n\016TCP_ENABLE_ECN\020\204\002\022"
  "\021\n\014TCP_FASTOPEN\020\205\002\022\030\n\023TCP_CONNECTION_INF"
  "O\020\206\002\022\r\n\010TCP_INFO\020\200\004\022\027\n\022TCP_MEASURE_SND_B"
  "W\020\202\004\022\026\n\021TCP_NOTSENT_LOWAT\020\201\004\022\031\n\024TCP_MEAS"
  "URE_BW_BURST\020\203\004\022\021\n\014TCP_PEER_PID\020\204\004\022\036\n\031TC"
  "P_ADAPTIVE_READ_TIMEOUT\020\205\004\022\024\n\017TCP_ENABLE"
  "_MSGS\020\206\004\022\037\n\032TCP_ADAPTIVE_WRITE_TIMEOUT\020\207"
  "\004\022\023\n\016TCP_NOTIMEWAIT\020\210\004\022$\n\037TCP_DISABLE_BL"
  "ACKHOLE_DETECTION\020\211\004\022\021\n\014TCP_ECN_MODE\020\220\004\022"
  "\032\n\025TCP_KEEPALIVE_OFFLOAD\020\221\004\022\024\n\020ECN_MODE_"
  "DEFAULT\020\000\022\023\n\017ECN_MODE_ENABLE\020\001\022\024\n\020ECN_MO"
  "DE_DISABLE\020\002\022\026\n\022TCP_MAX_NOTIFY_ACK\020\n\022\037\n\032"
  "TCP_NOTIFY_ACKNOWLEDGEMENT\020\222\004\022\027\n\022MPTCP_S"
  "ERVICE_TYPE\020\223\004\022\"\n\035TCP_FASTOPEN_FORCE_HEU"
  "RISTICS\020\224\004\022\032\n\026MPTCP_SVCTYPE_HANDOVER\020\000\022\035"
  "\n\031MPTCP_SVCTYPE_INTERACTIVE\020\001\022\033\n\027MPTCP_S"
  "VCTYPE_AGGREGATE\020\002\022\025\n\021MPTCP_SVCTYPE_MAX\020"
  "\003\022\034\n\027TCP_RXT_MINIMUM_TIMEOUT\020\225\004\022\031\n\024MPTCP"
  "_ALTERNATE_PORT\020\226\004\022\027\n\023TCPI_OPT_TIMESTAMP"
  "S\020\001\022\021\n\rTCPI_OPT_SACK\020\002\022\023\n\017TCPI_OPT_WSCAL"
  "E\020\004\022\020\n\014TCPI_OPT_ECN\020\010\022\032\n\026TCPI_FLAG_LOSSR"
  "ECOVERY\020\001\022\032\n\026TCPI_FLAG_STREAMING_ON\020\002\022\032\n"
  "\026CONNINFO_MPTCP_VERSION\020\003\022\027\n\023MPTCP_ITFST"
  "ATS_SIZE\020\004\022\026\n\022MPTCPCI_FIRSTPARTY\020\001\022\030\n\024TC"
  "PCI_OPT_TIMESTAMPS\020\001\022\022\n\016TCPCI_OPT_SACK\020\002"
  "\022\024\n\020TCPCI_OPT_WSCALE\020\004\022\021\n\rTCPCI_OPT_ECN\020"
  "\010\022\033\n\027TCPCI_FLAG_LOSSRECOVERY\020\001\022\"\n\036TCPCI_"
  "FLAG_REORDERING_DETECTED\020\002\022\016\n\nIP_OPTIONS"
  "\020\001\022\016\n\nIP_HDRINCL\020\002\022\n\n\006IP_TOS\020\003\022\n\n\006IP_TTL"
  "\020\004\022\017\n\013IP_RECVOPTS\020\005\022\022\n\016IP_RECVRETOPTS\020\006\022"
  "\022\n\016IP_RECVDSTADDR\020\007\022\016\n\nIP_RETOPTS\020\010\022\023\n\017I"
  "P_MULTICAST_IF\020\t\022\024\n\020IP_MULTICAST_TTL\020\n\022\025"
  "\n\021IP_MULTICAST_LOOP\020\013\022\025\n\021IP_ADD_MEMBERSH"
  "IP\020\014\022\026\n\022IP_DROP_MEMBERSHIP\020\r\022\024\n\020IP_MULTI"
  "CAST_VIF\020\016\022\016\n\nIP_RSVP_ON\020\017\022\017\n\013IP_RSVP_OF"
  "F\020\020\022\022\n\016IP_RSVP_VIF_ON\020\021\022\023\n\017IP_RSVP_VIF_O"
  "FF\020\022\022\020\n\014IP_PORTRANGE\020\023\022\r\n\tIP_RECVIF\020\024\022\023\n"
  "\017IP_IPSEC_POLICY\020\025\022\014\n\010IP_FAITH\020\026\022\017\n\013IP_S"
  "TRIPHDR\020\027\022\016\n\nIP_RECVTTL\020\030\022\017\n\013IP_BOUND_IF"
  "\020\031\022\016\n\nIP_PKTINFO\020\032\022\016\n\nIP_RECVTOS\020\033\022\r\n\tIP"
  "_FW_ADD\020(\022\r\n\tIP_FW_DEL\020)\022\017\n\013IP_FW_FLUSH\020"
  "*\022\016\n\nIP_FW_ZERO\020+\022\r\n\tIP_FW_GET\020,\022\022\n\016IP_F"
  "W_RESETLOG\020-\022\021\n\rIP_OLD_FW_ADD\0202\022\021\n\rIP_OL"
  "D_FW_DEL\0203\022\023\n\017IP_OLD_FW_FLUSH\0204\022\022\n\016IP_OL"
  "D_FW_ZERO\0205\022\021\n\rIP_OLD_FW_GET\0206\022\017\n\013IP_NAT"
  "__XXX\0207\022\026\n\022IP_OLD_FW_RESETLOG\0208\022\031\n\025IP_DU"
  "MMYNET_CONFIGURE\020<\022\023\n\017IP_DUMMYNET_DEL\020=\022"
  "\025\n\021IP_DUMMYNET_FLUSH\020>\022\023\n\017IP_DUMMYNET_GE"
  "T\020@\022\035\n\031IP_TRAFFIC_MGT_BACKGROUND\020A\022\030\n\024IP"
  "_MULTICAST_IFINDEX\020B\022\034\n\030IP_ADD_SOURCE_ME"
  "MBERSHIP\020F\022\035\n\031IP_DROP_SOURCE_MEMBERSHIP\020"
  "G\022\023\n\017IP_BLOCK_SOURCE\020H\022\025\n\021IP_UNBLOCK_SOU"
  "RCE\020I\022\017\n\013IP_MSFILTER\020J\022\024\n\020MCAST_JOIN_GRO"
  "UP\020P\022\025\n\021MCAST_LEAVE_GROUP\020Q\022\033\n\027MCAST_JOI"
  "N_SOURCE_GROUP\020R\022\034\n\030MCAST_LEAVE_SOURCE_G"
  "ROUP\020S\022\026\n\022MCAST_BLOCK_SOURCE\020T\022\030\n\024MCAST_"
  "UNBLOCK_SOURCE\020U\022\024\n\020IP_FORCE_OUT_IFP\020E\022\027"
  "\n\022IP_NO_IFT_CELLULAR\020\2716\022\016\n\tIP_OUT_IF\020\340K\022"
  "\034\n\030IP_DEFAULT_MULTICAST_TTL\020\001\022\035\n\031IP_DEFA"
  "ULT_MULTICAST_LOOP\020\001\022\026\n\022IP_MIN_MEMBERSHI"
  "PS\020\037\022\027\n\022IP_MAX_MEMBERSHIPS\020\377\037\022\034\n\027IP_MAX_"
  "GROUP_SRC_FILTER\020\200\004\022\033\n\026IP_MAX_SOCK_SRC_F"
  "ILTER\020\200\001\022\034\n\027IP_MAX_SOCK_MUTE_FILTER\020\200\001\022\021"
  "\n\rMCAST_INCLUDE\020\001\022\021\n\rMCAST_EXCLUDE\020\002\022\030\n\024"
  "IP_PORTRANGE_DEFAULT\020\000\022\025\n\021IP_PORTRANGE_H"
  "IGH\020\001\022\024\n\020IP_PORTRANGE_LOW\020\002\022\024\n\020IPCTL_FOR"
  "WARDING\020\001\022\027\n\023IPCTL_SENDREDIRECTS\020\002\022\020\n\014IP"
  "CTL_DEFTTL\020\003\022\020\n\014IPCTL_DEFMTU\020\004\022\022\n\016IPCTL_"
  "RTEXPIRE\020\005\022\025\n\021IPCTL_RTMINEXPIRE\020\006\022\024\n\020IPC"
  "TL_RTMAXCACHE\020\007\022\025\n\021IPCTL_SOURCEROUTE\020\010\022\033"
  "\n\027IPCTL_DIRECTEDBROADCAST\020\t\022\025\n\021IPCTL_INT"
  "RQMAXLEN\020\n\022\024\n\020IPCTL_INTRQDROPS\020\013\022\017\n\013IPCT"
  "L_STATS\020\014\022\033\n\027IPCTL_ACCEPTSOURCEROUTE\020\r\022\030"
  "\n\024IPCTL_FASTFORWARDING\020\016\022\023\n\017IPCTL_KEEPFA"
  "ITH\020\017\022\021\n\rIPCTL_GIF_TTL\020\020\022\017\n\013IPCTL_MAXID\020"
  "\021\022\014\n\010_DSCP_DF\020\000\022\r\n\t_DSCP_CS0\020\000\022\r\n\t_DSCP_"
  "CS1\020\010\022\r\n\t_DSCP_CS2\020\020\022\r\n\t_DSCP_CS3\020\030\022\r\n\t_"
  "DSCP_CS4\020 \022\r\n\t_DSCP_CS5\020(\022\r\n\t_DSCP_CS6\0200"
  "\022\r\n\t_DSCP_CS7\0208\022\014\n\010_DSCP_EF\020.\022\014\n\010_DSCP_V"
  "A\020,\022\016\n\n_DSCP_AF11\020\n\022\016\n\n_DSCP_AF12\020\014\022\016\n\n_"
  "DSCP_AF13\020\016\022\016\n\n_DSCP_AF21\020\022\022\016\n\n_DSCP_AF2"
  "2\020\024\022\016\n\n_DSCP_AF23\020\026\022\016\n\n_DSCP_AF31\020\032\022\016\n\n_"
  "DSCP_AF32\020\034\022\016\n\n_DSCP_AF33\020\036\022\016\n\n_DSCP_AF4"
  "1\020\"\022\016\n\n_DSCP_AF42\020$\022\016\n\n_DSCP_AF43\020&\022\014\n\010_"
  "DSCP_52\0204\022\r\n\t_MAX_DSCP\020\?\022\020\n\014IPV6_OPTIONS"
  "\020\001\022\021\n\rIPV6_RECVOPTS\020\005\022\024\n\020IPV6_RECVRETOPT"
  "S\020\006\022\024\n\020IPV6_RECVDSTADDR\020\007\022\020\n\014IPV6_RETOPT"
  "S\020\010\022\032\n\026IPV6_SOCKOPT_RESERVED1\020\003\022\025\n\021IPV6_"
  "UNICAST_HOPS\020\004\022\025\n\021IPV6_MULTICAST_IF\020\t\022\027\n"
  "\023IPV6_MULTICAST_HOPS\020\n\022\027\n\023IPV6_MULTICAST"
  "_LOOP\020\013\022\023\n\017IPV6_JOIN_GROUP\020\014\022\024\n\020IPV6_LEA"
  "VE_GROUP\020\r\022\022\n\016IPV6_PORTRANGE\020\016\022\020\n\014ICMP6_"
  "FILTER\020\022\022\024\n\020IPV6_2292PKTINFO\020\023\022\025\n\021IPV6_2"
  "292HOPLIMIT\020\024\022\024\n\020IPV6_2292NEXTHOP\020\025\022\024\n\020I"
  "PV6_2292HOPOPTS\020\026\022\024\n\020IPV6_2292DSTOPTS\020\027\022"
  "\022\n\016IPV6_2292RTHDR\020\030\022\027\n\023IPV6_2292PKTOPTIO"
  "NS\020\031\022\021\n\rIPV6_CHECKSUM\020\032\022\017\n\013IPV6_V6ONLY\020\033"
  "\022\025\n\021IPV6_IPSEC_POLICY\020\034\022\016\n\nIPV6_FAITH\020\035\022"
  "\017\n\013IPV6_FW_ADD\020\036\022\017\n\013IPV6_FW_DEL\020\037\022\021\n\rIPV"
  "6_FW_FLUSH\020 \022\020\n\014IPV6_FW_ZERO\020!\022\017\n\013IPV6_F"
  "W_GET\020\"\022\023\n\017IPV6_RECVTCLASS\020#\022\017\n\013IPV6_TCL"
  "ASS\020$\022\025\n\021IPV6_RTHDRDSTOPTS\0209\022\024\n\020IPV6_REC"
  "VPKTINFO\020=\022\025\n\021IPV6_RECVHOPLIMIT\020%\022\022\n\016IPV"
  "6_RECVRTHDR\020&\022\024\n\020IPV6_RECVHOPOPTS\020\'\022\024\n\020I"
  "PV6_RECVDSTOPTS\020(\022\031\n\025IPV6_RECVRTHDRDSTOP"
  "TS\020)\022\024\n\020IPV6_USE_MIN_MTU\020*\022\024\n\020IPV6_RECVP"
  "ATHMTU\020+\022\020\n\014IPV6_PATHMTU\020,\022\022\n\016IPV6_REACH"
  "CONF\020-\022\024\n\020IPV6_3542PKTINFO\020.\022\025\n\021IPV6_354"
  "2HOPLIMIT\020/\022\024\n\020IPV6_3542NEXTHOP\0200\022\024\n\020IPV"
  "6_3542HOPOPTS\0201\022\024\n\020IPV6_3542DSTOPTS\0202\022\022\n"
  "\016IPV6_3542RTHDR\0203\022\026\n\022IPV6_AUTOFLOWLABEL\020"
  ";\022\021\n\rIPV6_DONTFRAG\020>\022\030\n\024IPV6_PREFER_TEMP"
  "ADDR\020\?\022\021\n\rIPV6_MSFILTER\020J\022\021\n\rIPV6_BOUND_"
  "IF\020}\022\031\n\024IPV6_NO_IFT_CELLULAR\020\2716\022\020\n\013IPV6_"
  "OUT_IF\020\340K\022\024\n\020IPV6_RTHDR_LOOSE\020\000\022\025\n\021IPV6_"
  "RTHDR_STRICT\020\001\022\034\n\030IPV6_RTHDR_TYPE_0_SOCK"
  "ET\020\000\022\037\n\033IPV6_DEFAULT_MULTICAST_HOPS\020\001\022\037\n"
  "\033IPV6_DEFAULT_MULTICAST_LOOP\020\001\022\030\n\024IPV6_M"
  "IN_MEMBERSHIPS\020\037\022\031\n\024IPV6_MAX_MEMBERSHIPS"
  "\020\377\037\022\036\n\031IPV6_MAX_GROUP_SRC_FILTER\020\200\004\022\035\n\030I"
  "PV6_MAX_SOCK_SRC_FILTER\020\200\001\022\032\n\026IPV6_PORTR"
  "ANGE_DEFAULT\020\000\022\027\n\023IPV6_PORTRANGE_HIGH\020\001\022"
  "\026\n\022IPV6_PORTRANGE_LOW\020\002\022\026\n\022IPV6CTL_FORWA"
  "RDING\020\001\022\031\n\025IPV6CTL_SENDREDIRECTS\020\002\022\023\n\017IP"
  "V6CTL_DEFHLIM\020\003\022\022\n\016IPV6CTL_DEFMTU\020\004\022\025\n\021I"
  "PV6CTL_FORWSRCRT\020\005\022\021\n\rIPV6CTL_STATS\020\006\022\024\n"
  "\020IPV6CTL_MRTSTATS\020\007\022\024\n\020IPV6CTL_MRTPROTO\020"
  "\010\022\032\n\026IPV6CTL_MAXFRAGPACKETS\020\t\022\027\n\023IPV6CTL"
  "_SOURCECHECK\020\n\022\036\n\032IPV6CTL_SOURCECHECK_LO"
  "GINT\020\013\022\030\n\024IPV6CTL_ACCEPT_RTADV\020\014\022\025\n\021IPV6"
  "CTL_KEEPFAITH\020\r\022\030\n\024IPV6CTL_LOG_INTERVAL\020"
  "\016\022\030\n\024IPV6CTL_HDRNESTLIMIT\020\017\022\025\n\021IPV6CTL_D"
  "AD_COUNT\020\020\022\032\n\026IPV6CTL_AUTO_FLOWLABEL\020\021\022\030"
  "\n\024IPV6CTL_DEFMCASTHLIM\020\022\022\024\n\020IPV6CTL_GIF_"
  "HLIM\020\023\022\030\n\024IPV6CTL_KAME_VERSION\020\024\022\032\n\026IPV6"
  "CTL_USE_DEPRECATED\020\025\022\024\n\020IPV6CTL_RR_PRUNE"
  "\020\026\022\027\n\023IPV6CTL_MAPPED_ADDR\020\027\022\022\n\016IPV6CTL_V"
  "6ONLY\020\030\022\024\n\020IPV6CTL_RTEXPIRE\020\031\022\027\n\023IPV6CTL"
  "_RTMINEXPIRE\020\032\022\026\n\022IPV6CTL_RTMAXCACHE\020\033\022\027"
  "\n\023IPV6CTL_USETEMPADDR\020 \022\026\n\022IPV6CTL_TEMPP"
  "LTIME\020!\022\026\n\022IPV6CTL_TEMPVLTIME\020\"\022\032\n\026IPV6C"
  "TL_AUTO_LINKLOCAL\020#\022\025\n\021IPV6CTL_RIP6STATS"
  "\020$\022\033\n\027IPV6CTL_PREFER_TEMPADDR\020%\022\031\n\025IPV6C"
  "TL_ADDRCTLPOLICY\020&\022\033\n\027IPV6CTL_USE_DEFAUL"
  "TZONE\020\'\022\024\n\020IPV6CTL_MAXFRAGS\020)\022\026\n\022IPV6CTL"
  "_MCAST_PMTU\020,\022\034\n\030IPV6CTL_NEIGHBORGCTHRES"
  "H\020.\022\031\n\025IPV6CTL_MAXIFPREFIXES\020/\022\033\n\027IPV6CT"
  "L_MAXIFDEFROUTERS\0200\022\030\n\024IPV6CTL_MAXDYNROU"
  "TES\0201\022!\n\035ICMPV6CTL_ND6_ONLINKNSRFC4861\0202"
  "\022\021\n\rIPV6CTL_MAXID\0203\032\002\020\001*t\n\016FileDescripto"
  "r\022\010\n\004FD_0\020\000\022\010\n\004FD_1\020\001\022\010\n\004FD_2\020\002\022\010\n\004FD_3\020"
  "\003\022\010\n\004FD_4\020\004\022\010\n\004FD_5\020\005\022\010\n\004FD_6\020\006\022\010\n\004FD_7\020"
  "\007\022\010\n\004FD_8\020\010\022\010\n\004FD_9\020\t*\323\004\n\006Domain\022\r\n\tAF_U"
  "NSPEC\020\000\022\013\n\007AF_UNIX\020\001\022\013\n\007AF_INET\020\002\022\016\n\nAF_"
  "IMPLINK\020\003\022\n\n\006AF_PUP\020\004\022\014\n\010AF_CHAOS\020\005\022\t\n\005A"
  "F_NS\020\006\022\n\n\006AF_ISO\020\007\022\013\n\007AF_ECMA\020\010\022\016\n\nAF_DA"
  "TAKIT\020\t\022\014\n\010AF_CCITT\020\n\022\n\n\006AF_SNA\020\013\022\r\n\tAF_"
  "DECnet\020\014\022\n\n\006AF_DLI\020\r\022\n\n\006AF_LAT\020\016\022\r\n\tAF_H"
  "YLINK\020\017\022\020\n\014AF_APPLETALK\020\020\022\014\n\010AF_ROUTE\020\021\022"
  "\013\n\007AF_LINK\020\022\022\021\n\rpseudo_AF_XTP\020\023\022\013\n\007AF_CO"
  "IP\020\024\022\n\n\006AF_CNT\020\025\022\022\n\016pseudo_AF_RTIP\020\026\022\n\n\006"
  "AF_IPX\020\027\022\n\n\006AF_SIP\020\030\022\021\n\rpseudo_AF_PIP\020\031\022"
  "\013\n\007AF_NDRV\020\033\022\013\n\007AF_ISDN\020\034\022\021\n\rpseudo_AF_K"
  "EY\020\035\022\014\n\010AF_INET6\020\036\022\013\n\007AF_NATM\020\037\022\r\n\tAF_SY"
  "STEM\020 \022\016\n\nAF_NETBIOS\020!\022\n\n\006AF_PPP\020\"\022\026\n\022ps"
  "eudo_AF_HDRCMPLT\020#\022\022\n\016AF_RESERVED_36\020$\022\020"
  "\n\014AF_IEEE80211\020%\022\013\n\007AF_UTUN\020&\022\020\n\014AF_MULT"
  "IPATH\020\'\022\n\n\006AF_MAX\020(*Y\n\006SoType\022\017\n\013SOCK_ST"
  "REAM\020\001\022\016\n\nSOCK_DGRAM\020\002\022\014\n\010SOCK_RAW\020\003\022\014\n\010"
  "SOCK_RDM\020\004\022\022\n\016SOCK_SEQPACKET\020\005*\216\017\n\010Proto"
  "col\022\016\n\nIPPROTO_IP\020\000\022\020\n\014IPPROTO_ICMP\020\001\022\020\n"
  "\014IPPROTO_IGMP\020\002\022\017\n\013IPPROTO_GGP\020\003\022\020\n\014IPPR"
  "OTO_IPV4\020\004\022\017\n\013IPPROTO_TCP\020\006\022\016\n\nIPPROTO_S"
  "T\020\007\022\017\n\013IPPROTO_EGP\020\010\022\020\n\014IPPROTO_PIGP\020\t\022\022"
  "\n\016IPPROTO_RCCMON\020\n\022\021\n\rIPPROTO_NVPII\020\013\022\017\n"
  "\013IPPROTO_PUP\020\014\022\021\n\rIPPROTO_ARGUS\020\r\022\021\n\rIPP"
  "ROTO_EMCON\020\016\022\020\n\014IPPROTO_XNET\020\017\022\021\n\rIPPROT"
  "O_CHAOS\020\020\022\017\n\013IPPROTO_UDP\020\021\022\017\n\013IPPROTO_MU"
  "X\020\022\022\020\n\014IPPROTO_MEAS\020\023\022\017\n\013IPPROTO_HMP\020\024\022\017"
  "\n\013IPPROTO_PRM\020\025\022\017\n\013IPPROTO_IDP\020\026\022\022\n\016IPPR"
  "OTO_TRUNK1\020\027\022\022\n\016IPPROTO_TRUNK2\020\030\022\021\n\rIPPR"
  "OTO_LEAF1\020\031\022\021\n\rIPPROTO_LEAF2\020\032\022\017\n\013IPPROT"
  "O_RDP\020\033\022\020\n\014IPPROTO_IRTP\020\034\022\016\n\nIPPROTO_TP\020"
  "\035\022\017\n\013IPPROTO_BLT\020\036\022\017\n\013IPPROTO_NSP\020\037\022\017\n\013I"
  "PPROTO_INP\020 \022\017\n\013IPPROTO_SEP\020!\022\017\n\013IPPROTO"
  "_3PC\020\"\022\020\n\014IPPROTO_IDPR\020#\022\017\n\013IPPROTO_XTP\020"
  "$\022\017\n\013IPPROTO_DDP\020%\022\020\n\014IPPROTO_CMTP\020&\022\020\n\014"
  "IPPROTO_TPXX\020\'\022\016\n\nIPPROTO_IL\020(\022\020\n\014IPPROT"
  "O_IPV6\020)\022\020\n\014IPPROTO_SDRP\020*\022\022\n\016IPPROTO_RO"
  "UTIN\020+\022\023\n\017IPPROTO_FRAGMEN\020,\022\020\n\014IPPROTO_I"
  "DRP\020-\022\020\n\014IPPROTO_RSVP\020.\022\017\n\013IPPROTO_GRE\020/"
  "\022\020\n\014IPPROTO_MHRP\0200\022\017\n\013IPPROTO_BHA\0201\022\017\n\013I"
  "PPROTO_ESP\0202\022\016\n\nIPPROTO_AH\0203\022\021\n\rIPPROTO_"
  "INLSP\0204\022\021\n\rIPPROTO_SWIPE\0205\022\020\n\014IPPROTO_NH"
  "RP\0206\022\022\n\016IPPROTO_ICMPV6\020:\022\020\n\014IPPROTO_NONE"
  "\020;\022\023\n\017IPPROTO_DSTOPTS\020<\022\020\n\014IPPROTO_AHIP\020"
  "=\022\020\n\014IPPROTO_CFTP\020>\022\021\n\rIPPROTO_HELLO\020\?\022\023"
  "\n\017IPPROTO_SATEXPA\020@\022\024\n\020IPPROTO_KRYPTOLA\020"
  "A\022\017\n\013IPPROTO_RVD\020B\022\020\n\014IPPROTO_IPPC\020C\022\020\n\014"
  "IPPROTO_ADFS\020D\022\022\n\016IPPROTO_SATMON\020E\022\020\n\014IP"
  "PROTO_VISA\020F\022\020\n\014IPPROTO_IPCV\020G\022\020\n\014IPPROT"
  "O_CPNX\020H\022\020\n\014IPPROTO_CPHB\020I\022\017\n\013IPPROTO_WS"
  "N\020J\022\017\n\013IPPROTO_PVP\020K\022\023\n\017IPPROTO_BRSATMO\020"
  "L\022\016\n\nIPPROTO_ND\020M\022\021\n\rIPPROTO_WBMON\020N\022\023\n\017"
  "IPPROTO_WBEXPAK\020O\022\017\n\013IPPROTO_EON\020P\022\020\n\014IP"
  "PROTO_VMTP\020Q\022\021\n\rIPPROTO_SVMTP\020R\022\021\n\rIPPRO"
  "TO_VINES\020S\022\017\n\013IPPROTO_TTP\020T\022\017\n\013IPPROTO_I"
  "GP\020U\022\017\n\013IPPROTO_DGP\020V\022\017\n\013IPPROTO_TCF\020W\022\020"
  "\n\014IPPROTO_IGRP\020X\022\023\n\017IPPROTO_OSPFIGP\020Y\022\020\n"
  "\014IPPROTO_SRPC\020Z\022\020\n\014IPPROTO_LARP\020[\022\017\n\013IPP"
  "ROTO_MTP\020\\\022\020\n\014IPPROTO_AX25\020]\022\021\n\rIPPROTO_"
  "IPEIP\020^\022\020\n\014IPPROTO_MICP\020_\022\021\n\rIPPROTO_SCC"
  "SP\020`\022\023\n\017IPPROTO_ETHERIP\020a\022\021\n\rIPPROTO_ENC"
  "AP\020b\022\020\n\014IPPROTO_APES\020c\022\020\n\014IPPROTO_GMTP\020d"
  "\022\017\n\013IPPROTO_PIM\020g\022\022\n\016IPPROTO_IPCOMP\020l\022\017\n"
  "\013IPPROTO_PGM\020q\022\021\n\014IPPROTO_SCTP\020\204\001\022\023\n\016IPP"
  "ROTO_DIVERT\020\376\001\022\020\n\013IPPROTO_RAW\020\377\001\022\020\n\013IPPR"
  "OTO_MAX\020\200\002\022\021\n\014IPPROTO_DONE\020\201\002\022\020\n\nSOL_SOC"
  "KET\020\377\377\003"
  ;
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_net_5ffuzzer_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_net_5ffuzzer_2eproto = {
  false, false, 28087, descriptor_table_protodef_net_5ffuzzer_2eproto, "net_fuzzer.proto", 
  &descriptor_table_net_5ffuzzer_2eproto_once, nullptr, 0, 62,
  schemas, file_default_instances, TableStruct_net_5ffuzzer_2eproto::offsets,
  file_level_metadata_net_5ffuzzer_2eproto, file_level_enum_descriptors_net_5ffuzzer_2eproto, file_level_service_descriptors_net_5ffuzzer_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_net_5ffuzzer_2eproto_getter() {
  return &descriptor_table_net_5ffuzzer_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_net_5ffuzzer_2eproto(&descriptor_table_net_5ffuzzer_2eproto);
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SaeAssocID_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[0];
}
bool SaeAssocID_IsValid(int value) {
  switch (value) {
    case -1:
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* In6Addr_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[1];
}
bool In6Addr_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 16777216:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* InAddr_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[2];
}
bool InAddr_IsValid(int value) {
  switch (value) {
    case -1062709672:
    case -1:
    case 0:
    case 1:
    case 2:
    case 411187920:
    case 2130706433:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FlowInfo_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[3];
}
bool FlowInfo_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ScopeId_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[4];
}
bool ScopeId_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 50:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Port_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[5];
}
bool Port_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 5555:
    case 65000:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IfIdx_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[6];
}
bool IfIdx_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConnectXFlag_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[7];
}
bool ConnectXFlag_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ShutdownHow_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[8];
}
bool ShutdownHow_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NecpOpenFlag_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[9];
}
bool NecpOpenFlag_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NecpClientId_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[10];
}
bool NecpClientId_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NecpClientActionNumber_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[11];
}
bool NecpClientActionNumber_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NecpSessionActionNumber_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[12];
}
bool NecpSessionActionNumber_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IfrName_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[13];
}
bool IfrName_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IfruFlag_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[14];
}
bool IfruFlag_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 4:
    case 8:
    case 16:
    case 32:
    case 64:
    case 128:
    case 256:
    case 512:
    case 1024:
    case 2048:
    case 4096:
    case 8192:
    case 16384:
    case 32768:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IfraFlag_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[15];
}
bool IfraFlag_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 4:
    case 8:
    case 16:
    case 32:
    case 64:
    case 128:
    case 256:
    case 512:
    case 1024:
    case 2048:
    case 4096:
    case 32768:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Ip6RtType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[16];
}
bool Ip6RtType_IsValid(int value) {
  switch (value) {
    case 0:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Icmp6Type_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[17];
}
bool Icmp6Type_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 128:
    case 129:
    case 130:
    case 131:
    case 132:
    case 133:
    case 134:
    case 135:
    case 136:
    case 137:
    case 138:
    case 139:
    case 140:
    case 143:
    case 200:
    case 201:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Icmp6Code_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[18];
}
bool Icmp6Code_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 128:
    case 255:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TcpSeq_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[19];
}
bool TcpSeq_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TcpFlag_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[20];
}
bool TcpFlag_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 4:
    case 8:
    case 16:
    case 32:
    case 64:
    case 128:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IpVersion_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[21];
}
bool IpVersion_IsValid(int value) {
  switch (value) {
    case 4:
    case 6:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IoctlIdx_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[22];
}
bool IoctlIdx_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
    case 40:
    case 41:
    case 42:
    case 43:
    case 44:
    case 45:
    case 46:
    case 47:
    case 48:
    case 49:
    case 50:
    case 51:
    case 52:
    case 53:
    case 54:
    case 55:
    case 56:
    case 57:
    case 58:
    case 59:
    case 60:
    case 61:
    case 62:
    case 63:
    case 64:
    case 65:
    case 66:
    case 67:
    case 68:
    case 69:
    case 70:
    case 71:
    case 72:
    case 73:
    case 74:
    case 75:
    case 76:
    case 77:
    case 78:
    case 79:
    case 80:
    case 81:
    case 82:
    case 83:
    case 84:
    case 85:
    case 86:
    case 87:
    case 88:
    case 89:
    case 90:
    case 91:
    case 92:
    case 93:
    case 94:
    case 95:
    case 96:
    case 97:
    case 98:
    case 99:
    case 100:
    case 101:
    case 102:
    case 103:
    case 104:
    case 105:
    case 106:
    case 107:
    case 108:
    case 109:
    case 110:
    case 111:
    case 112:
    case 113:
    case 114:
    case 115:
    case 116:
    case 117:
    case 118:
    case 119:
    case 120:
    case 121:
    case 122:
    case 123:
    case 124:
    case 125:
    case 126:
    case 127:
    case 128:
    case 129:
    case 130:
    case 131:
    case 132:
    case 133:
    case 134:
    case 135:
    case 136:
    case 137:
    case 138:
    case 139:
    case 140:
    case 141:
    case 142:
    case 143:
    case 144:
    case 145:
    case 146:
    case 147:
    case 148:
    case 149:
    case 150:
    case 151:
    case 152:
    case 153:
    case 154:
    case 155:
    case 156:
    case 157:
    case 158:
    case 159:
    case 160:
    case 161:
    case 162:
    case 163:
    case 164:
    case 165:
    case 166:
    case 167:
    case 168:
    case 169:
    case 170:
    case 171:
    case 172:
    case 173:
    case 174:
    case 175:
    case 176:
    case 177:
    case 178:
    case 179:
    case 180:
    case 181:
    case 182:
    case 183:
    case 184:
    case 185:
    case 186:
    case 187:
    case 188:
    case 189:
    case 190:
    case 191:
    case 192:
    case 193:
    case 194:
    case 195:
    case 196:
    case 197:
    case 198:
    case 199:
    case 200:
    case 201:
    case 202:
    case 203:
    case 204:
    case 205:
    case 206:
    case 207:
    case 208:
    case 209:
    case 210:
    case 211:
    case 212:
    case 213:
    case 214:
    case 215:
    case 216:
    case 217:
    case 218:
    case 219:
    case 220:
    case 221:
    case 222:
    case 223:
    case 224:
    case 225:
    case 226:
    case 227:
    case 228:
    case 229:
    case 230:
    case 231:
    case 232:
    case 233:
    case 234:
    case 235:
    case 236:
    case 237:
    case 238:
    case 239:
    case 240:
    case 241:
    case 242:
    case 243:
    case 244:
    case 245:
    case 246:
    case 247:
    case 248:
    case 249:
    case 250:
    case 251:
    case 252:
    case 253:
    case 254:
    case 255:
    case 256:
    case 257:
    case 258:
    case 259:
    case 260:
    case 261:
    case 262:
    case 263:
    case 264:
    case 265:
    case 266:
    case 267:
    case 268:
    case 269:
    case 270:
    case 271:
    case 272:
    case 273:
    case 274:
    case 275:
    case 276:
    case 277:
    case 278:
    case 279:
    case 280:
    case 281:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SocketOptName_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[23];
}
bool SocketOptName_IsValid(int value) {
  switch (value) {
    case -1:
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
    case 40:
    case 41:
    case 42:
    case 43:
    case 44:
    case 45:
    case 46:
    case 47:
    case 48:
    case 49:
    case 50:
    case 51:
    case 52:
    case 53:
    case 54:
    case 55:
    case 56:
    case 57:
    case 59:
    case 60:
    case 61:
    case 62:
    case 63:
    case 64:
    case 65:
    case 66:
    case 69:
    case 70:
    case 71:
    case 72:
    case 73:
    case 74:
    case 80:
    case 81:
    case 82:
    case 83:
    case 84:
    case 85:
    case 100:
    case 125:
    case 128:
    case 200:
    case 216:
    case 256:
    case 257:
    case 258:
    case 259:
    case 260:
    case 261:
    case 262:
    case 300:
    case 400:
    case 500:
    case 512:
    case 513:
    case 514:
    case 515:
    case 516:
    case 517:
    case 518:
    case 519:
    case 520:
    case 521:
    case 528:
    case 529:
    case 530:
    case 531:
    case 532:
    case 533:
    case 534:
    case 600:
    case 700:
    case 800:
    case 900:
    case 1024:
    case 2048:
    case 4095:
    case 4096:
    case 4097:
    case 4098:
    case 4099:
    case 4100:
    case 4101:
    case 4102:
    case 4103:
    case 4104:
    case 4112:
    case 4113:
    case 4128:
    case 4129:
    case 4130:
    case 4131:
    case 4132:
    case 4133:
    case 4134:
    case 4135:
    case 4224:
    case 4225:
    case 4226:
    case 4227:
    case 4229:
    case 4230:
    case 4231:
    case 4232:
    case 4233:
    case 4240:
    case 4241:
    case 4352:
    case 4353:
    case 4354:
    case 4355:
    case 4356:
    case 4357:
    case 4358:
    case 4359:
    case 4360:
    case 4361:
    case 4368:
    case 4369:
    case 4370:
    case 4371:
    case 4372:
    case 4373:
    case 4374:
    case 4375:
    case 4376:
    case 4377:
    case 6969:
    case 8192:
    case 9696:
    case 10000:
    case 16384:
    case 32768:
    case 65535:
    case 65536:
    case 131072:
    case 262144:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FileDescriptor_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[24];
}
bool FileDescriptor_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Domain_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[25];
}
bool Domain_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
    case 40:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SoType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[26];
}
bool SoType_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Protocol_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_net_5ffuzzer_2eproto);
  return file_level_enum_descriptors_net_5ffuzzer_2eproto[27];
}
bool Protocol_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
    case 40:
    case 41:
    case 42:
    case 43:
    case 44:
    case 45:
    case 46:
    case 47:
    case 48:
    case 49:
    case 50:
    case 51:
    case 52:
    case 53:
    case 54:
    case 58:
    case 59:
    case 60:
    case 61:
    case 62:
    case 63:
    case 64:
    case 65:
    case 66:
    case 67:
    case 68:
    case 69:
    case 70:
    case 71:
    case 72:
    case 73:
    case 74:
    case 75:
    case 76:
    case 77:
    case 78:
    case 79:
    case 80:
    case 81:
    case 82:
    case 83:
    case 84:
    case 85:
    case 86:
    case 87:
    case 88:
    case 89:
    case 90:
    case 91:
    case 92:
    case 93:
    case 94:
    case 95:
    case 96:
    case 97:
    case 98:
    case 99:
    case 100:
    case 103:
    case 108:
    case 113:
    case 132:
    case 254:
    case 255:
    case 256:
    case 257:
    case 65535:
      return true;
    default:
      return false;
  }
}


// ===================================================================

class Session::_Internal {
 public:
  using HasBits = decltype(std::declval<Session>()._has_bits_);
  static void set_has_data_provider(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

Session::Session(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  commands_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Session)
}
Session::Session(const Session& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      commands_(from.commands_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  data_provider_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data_provider()) {
    data_provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data_provider(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:Session)
}

void Session::SharedCtor() {
data_provider_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

Session::~Session() {
  // @@protoc_insertion_point(destructor:Session)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Session::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  data_provider_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Session::ArenaDtor(void* object) {
  Session* _this = reinterpret_cast< Session* >(object);
  (void)_this;
}
void Session::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Session::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Session::Clear() {
// @@protoc_insertion_point(message_clear_start:Session)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  commands_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    data_provider_.ClearNonDefaultToEmpty();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Session::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .Command commands = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_commands(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // required bytes data_provider = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_data_provider();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Session::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Session)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .Command commands = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_commands_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_commands(i), target, stream);
  }

  cached_has_bits = _has_bits_[0];
  // required bytes data_provider = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_data_provider(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Session)
  return target;
}

size_t Session::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Session)
  size_t total_size = 0;

  // required bytes data_provider = 2;
  if (_internal_has_data_provider()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_data_provider());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .Command commands = 1;
  total_size += 1UL * this->_internal_commands_size();
  for (const auto& msg : this->commands_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Session::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Session::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Session::GetClassData() const { return &_class_data_; }

void Session::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Session *>(to)->MergeFrom(
      static_cast<const Session &>(from));
}


void Session::MergeFrom(const Session& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Session)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  commands_.MergeFrom(from.commands_);
  if (from._internal_has_data_provider()) {
    _internal_set_data_provider(from._internal_data_provider());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Session::CopyFrom(const Session& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Session)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Session::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(commands_)) return false;
  return true;
}

void Session::InternalSwap(Session* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  commands_.InternalSwap(&other->commands_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &data_provider_, lhs_arena,
      &other->data_provider_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata Session::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[0]);
}

// ===================================================================

class Connect::_Internal {
 public:
  using HasBits = decltype(std::declval<Connect>()._has_bits_);
  static const ::SockAddr& sockaddr(const Connect* msg);
  static void set_has_sockaddr(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_fd(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

const ::SockAddr&
Connect::_Internal::sockaddr(const Connect* msg) {
  return *msg->sockaddr_;
}
Connect::Connect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Connect)
}
Connect::Connect(const Connect& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_sockaddr()) {
    sockaddr_ = new ::SockAddr(*from.sockaddr_);
  } else {
    sockaddr_ = nullptr;
  }
  fd_ = from.fd_;
  // @@protoc_insertion_point(copy_constructor:Connect)
}

void Connect::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&sockaddr_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&fd_) -
    reinterpret_cast<char*>(&sockaddr_)) + sizeof(fd_));
}

Connect::~Connect() {
  // @@protoc_insertion_point(destructor:Connect)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Connect::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete sockaddr_;
}

void Connect::ArenaDtor(void* object) {
  Connect* _this = reinterpret_cast< Connect* >(object);
  (void)_this;
}
void Connect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Connect::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Connect::Clear() {
// @@protoc_insertion_point(message_clear_start:Connect)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(sockaddr_ != nullptr);
    sockaddr_->Clear();
  }
  fd_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Connect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .SockAddr sockaddr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_sockaddr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .FileDescriptor fd = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_fd(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Connect::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Connect)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .SockAddr sockaddr = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::sockaddr(this), target, stream);
  }

  // required .FileDescriptor fd = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_fd(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Connect)
  return target;
}

size_t Connect::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Connect)
  size_t total_size = 0;

  if (_internal_has_sockaddr()) {
    // required .SockAddr sockaddr = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *sockaddr_);
  }

  if (_internal_has_fd()) {
    // required .FileDescriptor fd = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fd());
  }

  return total_size;
}
size_t Connect::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Connect)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required .SockAddr sockaddr = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *sockaddr_);

    // required .FileDescriptor fd = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fd());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Connect::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Connect::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Connect::GetClassData() const { return &_class_data_; }

void Connect::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Connect *>(to)->MergeFrom(
      static_cast<const Connect &>(from));
}


void Connect::MergeFrom(const Connect& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Connect)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_sockaddr()->::SockAddr::MergeFrom(from._internal_sockaddr());
    }
    if (cached_has_bits & 0x00000002u) {
      fd_ = from.fd_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Connect::CopyFrom(const Connect& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Connect)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Connect::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_sockaddr()) {
    if (!sockaddr_->IsInitialized()) return false;
  }
  return true;
}

void Connect::InternalSwap(Connect* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Connect, fd_)
      + sizeof(Connect::fd_)
      - PROTOBUF_FIELD_OFFSET(Connect, sockaddr_)>(
          reinterpret_cast<char*>(&sockaddr_),
          reinterpret_cast<char*>(&other->sockaddr_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Connect::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[1]);
}

// ===================================================================

class ConnectX::_Internal {
 public:
  using HasBits = decltype(std::declval<ConnectX>()._has_bits_);
  static void set_has_socket(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::Endpoints& endpoints(const ConnectX* msg);
  static void set_has_endpoints(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_associd(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
  }
};

const ::Endpoints&
ConnectX::_Internal::endpoints(const ConnectX* msg) {
  return *msg->endpoints_;
}
ConnectX::ConnectX(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  flags_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:ConnectX)
}
ConnectX::ConnectX(const ConnectX& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      flags_(from.flags_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_endpoints()) {
    endpoints_ = new ::Endpoints(*from.endpoints_);
  } else {
    endpoints_ = nullptr;
  }
  ::memcpy(&socket_, &from.socket_,
    static_cast<size_t>(reinterpret_cast<char*>(&associd_) -
    reinterpret_cast<char*>(&socket_)) + sizeof(associd_));
  // @@protoc_insertion_point(copy_constructor:ConnectX)
}

void ConnectX::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&endpoints_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&associd_) -
    reinterpret_cast<char*>(&endpoints_)) + sizeof(associd_));
}

ConnectX::~ConnectX() {
  // @@protoc_insertion_point(destructor:ConnectX)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void ConnectX::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete endpoints_;
}

void ConnectX::ArenaDtor(void* object) {
  ConnectX* _this = reinterpret_cast< ConnectX* >(object);
  (void)_this;
}
void ConnectX::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ConnectX::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ConnectX::Clear() {
// @@protoc_insertion_point(message_clear_start:ConnectX)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  flags_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(endpoints_ != nullptr);
    endpoints_->Clear();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&socket_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&associd_) -
        reinterpret_cast<char*>(&socket_)) + sizeof(associd_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ConnectX::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .FileDescriptor socket = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_socket(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .Endpoints endpoints = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_endpoints(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .SaeAssocID associd = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SaeAssocID_IsValid(val))) {
            _internal_set_associd(static_cast<::SaeAssocID>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // repeated .ConnectXFlag flags = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ptr -= 1;
          do {
            ptr += 1;
            ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
            if (PROTOBUF_PREDICT_TRUE(::ConnectXFlag_IsValid(val))) {
              _internal_add_flags(static_cast<::ConnectXFlag>(val));
            } else {
              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
            }
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(_internal_mutable_flags(), ptr, ctx, ::ConnectXFlag_IsValid, &_internal_metadata_, 4);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ConnectX::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:ConnectX)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .FileDescriptor socket = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_socket(), target);
  }

  // required .Endpoints endpoints = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::endpoints(this), target, stream);
  }

  // required .SaeAssocID associd = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_associd(), target);
  }

  // repeated .ConnectXFlag flags = 4;
  for (int i = 0, n = this->_internal_flags_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        4, this->_internal_flags(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:ConnectX)
  return target;
}

size_t ConnectX::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:ConnectX)
  size_t total_size = 0;

  if (_internal_has_endpoints()) {
    // required .Endpoints endpoints = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *endpoints_);
  }

  if (_internal_has_socket()) {
    // required .FileDescriptor socket = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_socket());
  }

  if (_internal_has_associd()) {
    // required .SaeAssocID associd = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_associd());
  }

  return total_size;
}
size_t ConnectX::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:ConnectX)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required .Endpoints endpoints = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *endpoints_);

    // required .FileDescriptor socket = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_socket());

    // required .SaeAssocID associd = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_associd());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .ConnectXFlag flags = 4;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->_internal_flags_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
        this->_internal_flags(static_cast<int>(i)));
    }
    total_size += (1UL * count) + data_size;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ConnectX::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    ConnectX::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ConnectX::GetClassData() const { return &_class_data_; }

void ConnectX::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<ConnectX *>(to)->MergeFrom(
      static_cast<const ConnectX &>(from));
}


void ConnectX::MergeFrom(const ConnectX& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:ConnectX)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  flags_.MergeFrom(from.flags_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_endpoints()->::Endpoints::MergeFrom(from._internal_endpoints());
    }
    if (cached_has_bits & 0x00000002u) {
      socket_ = from.socket_;
    }
    if (cached_has_bits & 0x00000004u) {
      associd_ = from.associd_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void ConnectX::CopyFrom(const ConnectX& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ConnectX)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ConnectX::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_endpoints()) {
    if (!endpoints_->IsInitialized()) return false;
  }
  return true;
}

void ConnectX::InternalSwap(ConnectX* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  flags_.InternalSwap(&other->flags_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ConnectX, associd_)
      + sizeof(ConnectX::associd_)
      - PROTOBUF_FIELD_OFFSET(ConnectX, endpoints_)>(
          reinterpret_cast<char*>(&endpoints_),
          reinterpret_cast<char*>(&other->endpoints_));
}

::PROTOBUF_NAMESPACE_ID::Metadata ConnectX::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[2]);
}

// ===================================================================

class DisconnectX::_Internal {
 public:
  using HasBits = decltype(std::declval<DisconnectX>()._has_bits_);
  static void set_has_associd(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_cid(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_fd(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
  }
};

DisconnectX::DisconnectX(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:DisconnectX)
}
DisconnectX::DisconnectX(const DisconnectX& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&associd_, &from.associd_,
    static_cast<size_t>(reinterpret_cast<char*>(&fd_) -
    reinterpret_cast<char*>(&associd_)) + sizeof(fd_));
  // @@protoc_insertion_point(copy_constructor:DisconnectX)
}

void DisconnectX::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&associd_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&fd_) -
    reinterpret_cast<char*>(&associd_)) + sizeof(fd_));
}

DisconnectX::~DisconnectX() {
  // @@protoc_insertion_point(destructor:DisconnectX)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DisconnectX::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void DisconnectX::ArenaDtor(void* object) {
  DisconnectX* _this = reinterpret_cast< DisconnectX* >(object);
  (void)_this;
}
void DisconnectX::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DisconnectX::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DisconnectX::Clear() {
// @@protoc_insertion_point(message_clear_start:DisconnectX)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&associd_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&fd_) -
        reinterpret_cast<char*>(&associd_)) + sizeof(fd_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DisconnectX::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .SaeAssocID associd = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SaeAssocID_IsValid(val))) {
            _internal_set_associd(static_cast<::SaeAssocID>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required int32 cid = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_cid(&has_bits);
          cid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .FileDescriptor fd = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_fd(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* DisconnectX::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:DisconnectX)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .SaeAssocID associd = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_associd(), target);
  }

  // required int32 cid = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_cid(), target);
  }

  // required .FileDescriptor fd = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_fd(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:DisconnectX)
  return target;
}

size_t DisconnectX::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:DisconnectX)
  size_t total_size = 0;

  if (_internal_has_associd()) {
    // required .SaeAssocID associd = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_associd());
  }

  if (_internal_has_cid()) {
    // required int32 cid = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_cid());
  }

  if (_internal_has_fd()) {
    // required .FileDescriptor fd = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fd());
  }

  return total_size;
}
size_t DisconnectX::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:DisconnectX)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required .SaeAssocID associd = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_associd());

    // required int32 cid = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_cid());

    // required .FileDescriptor fd = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fd());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DisconnectX::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DisconnectX::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DisconnectX::GetClassData() const { return &_class_data_; }

void DisconnectX::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DisconnectX *>(to)->MergeFrom(
      static_cast<const DisconnectX &>(from));
}


void DisconnectX::MergeFrom(const DisconnectX& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:DisconnectX)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      associd_ = from.associd_;
    }
    if (cached_has_bits & 0x00000002u) {
      cid_ = from.cid_;
    }
    if (cached_has_bits & 0x00000004u) {
      fd_ = from.fd_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DisconnectX::CopyFrom(const DisconnectX& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:DisconnectX)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DisconnectX::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void DisconnectX::InternalSwap(DisconnectX* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DisconnectX, fd_)
      + sizeof(DisconnectX::fd_)
      - PROTOBUF_FIELD_OFFSET(DisconnectX, associd_)>(
          reinterpret_cast<char*>(&associd_),
          reinterpret_cast<char*>(&other->associd_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DisconnectX::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[3]);
}

// ===================================================================

class IOV::_Internal {
 public:
  using HasBits = decltype(std::declval<IOV>()._has_bits_);
  static void set_has_iov_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

IOV::IOV(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:IOV)
}
IOV::IOV(const IOV& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  iov_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_iov_data()) {
    iov_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_iov_data(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:IOV)
}

void IOV::SharedCtor() {
iov_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

IOV::~IOV() {
  // @@protoc_insertion_point(destructor:IOV)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void IOV::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  iov_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void IOV::ArenaDtor(void* object) {
  IOV* _this = reinterpret_cast< IOV* >(object);
  (void)_this;
}
void IOV::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void IOV::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void IOV::Clear() {
// @@protoc_insertion_point(message_clear_start:IOV)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    iov_data_.ClearNonDefaultToEmpty();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* IOV::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required bytes iov_data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_iov_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* IOV::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:IOV)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bytes iov_data = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_iov_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:IOV)
  return target;
}

size_t IOV::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:IOV)
  size_t total_size = 0;

  // required bytes iov_data = 1;
  if (_internal_has_iov_data()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_iov_data());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData IOV::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    IOV::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*IOV::GetClassData() const { return &_class_data_; }

void IOV::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<IOV *>(to)->MergeFrom(
      static_cast<const IOV &>(from));
}


void IOV::MergeFrom(const IOV& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:IOV)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_iov_data()) {
    _internal_set_iov_data(from._internal_iov_data());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void IOV::CopyFrom(const IOV& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:IOV)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool IOV::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void IOV::InternalSwap(IOV* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &iov_data_, lhs_arena,
      &other->iov_data_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata IOV::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[4]);
}

// ===================================================================

class Endpoints::_Internal {
 public:
  using HasBits = decltype(std::declval<Endpoints>()._has_bits_);
  static void set_has_sae_srcif(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SockAddr& sae_srcaddr(const Endpoints* msg);
  static void set_has_sae_srcaddr(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SockAddr& sae_dstaddr(const Endpoints* msg);
  static void set_has_sae_dstaddr(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000006) ^ 0x00000006) != 0;
  }
};

const ::SockAddr&
Endpoints::_Internal::sae_srcaddr(const Endpoints* msg) {
  return *msg->sae_srcaddr_;
}
const ::SockAddr&
Endpoints::_Internal::sae_dstaddr(const Endpoints* msg) {
  return *msg->sae_dstaddr_;
}
Endpoints::Endpoints(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Endpoints)
}
Endpoints::Endpoints(const Endpoints& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_sae_srcaddr()) {
    sae_srcaddr_ = new ::SockAddr(*from.sae_srcaddr_);
  } else {
    sae_srcaddr_ = nullptr;
  }
  if (from._internal_has_sae_dstaddr()) {
    sae_dstaddr_ = new ::SockAddr(*from.sae_dstaddr_);
  } else {
    sae_dstaddr_ = nullptr;
  }
  sae_srcif_ = from.sae_srcif_;
  // @@protoc_insertion_point(copy_constructor:Endpoints)
}

void Endpoints::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&sae_srcaddr_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&sae_srcif_) -
    reinterpret_cast<char*>(&sae_srcaddr_)) + sizeof(sae_srcif_));
}

Endpoints::~Endpoints() {
  // @@protoc_insertion_point(destructor:Endpoints)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Endpoints::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete sae_srcaddr_;
  if (this != internal_default_instance()) delete sae_dstaddr_;
}

void Endpoints::ArenaDtor(void* object) {
  Endpoints* _this = reinterpret_cast< Endpoints* >(object);
  (void)_this;
}
void Endpoints::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Endpoints::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Endpoints::Clear() {
// @@protoc_insertion_point(message_clear_start:Endpoints)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(sae_srcaddr_ != nullptr);
      sae_srcaddr_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(sae_dstaddr_ != nullptr);
      sae_dstaddr_->Clear();
    }
  }
  sae_srcif_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Endpoints::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .IfIdx sae_srcif = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::IfIdx_IsValid(val))) {
            _internal_set_sae_srcif(static_cast<::IfIdx>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .SockAddr sae_srcaddr = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_sae_srcaddr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .SockAddr sae_dstaddr = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_sae_dstaddr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Endpoints::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Endpoints)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .IfIdx sae_srcif = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_sae_srcif(), target);
  }

  // optional .SockAddr sae_srcaddr = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::sae_srcaddr(this), target, stream);
  }

  // required .SockAddr sae_dstaddr = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::sae_dstaddr(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Endpoints)
  return target;
}

size_t Endpoints::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Endpoints)
  size_t total_size = 0;

  if (_internal_has_sae_dstaddr()) {
    // required .SockAddr sae_dstaddr = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *sae_dstaddr_);
  }

  if (_internal_has_sae_srcif()) {
    // required .IfIdx sae_srcif = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sae_srcif());
  }

  return total_size;
}
size_t Endpoints::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Endpoints)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000006) ^ 0x00000006) == 0) {  // All required fields are present.
    // required .SockAddr sae_dstaddr = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *sae_dstaddr_);

    // required .IfIdx sae_srcif = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sae_srcif());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .SockAddr sae_srcaddr = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *sae_srcaddr_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Endpoints::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Endpoints::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Endpoints::GetClassData() const { return &_class_data_; }

void Endpoints::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Endpoints *>(to)->MergeFrom(
      static_cast<const Endpoints &>(from));
}


void Endpoints::MergeFrom(const Endpoints& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Endpoints)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_sae_srcaddr()->::SockAddr::MergeFrom(from._internal_sae_srcaddr());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_sae_dstaddr()->::SockAddr::MergeFrom(from._internal_sae_dstaddr());
    }
    if (cached_has_bits & 0x00000004u) {
      sae_srcif_ = from.sae_srcif_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Endpoints::CopyFrom(const Endpoints& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Endpoints)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Endpoints::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_sae_srcaddr()) {
    if (!sae_srcaddr_->IsInitialized()) return false;
  }
  if (_internal_has_sae_dstaddr()) {
    if (!sae_dstaddr_->IsInitialized()) return false;
  }
  return true;
}

void Endpoints::InternalSwap(Endpoints* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Endpoints, sae_srcif_)
      + sizeof(Endpoints::sae_srcif_)
      - PROTOBUF_FIELD_OFFSET(Endpoints, sae_srcaddr_)>(
          reinterpret_cast<char*>(&sae_srcaddr_),
          reinterpret_cast<char*>(&other->sae_srcaddr_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Endpoints::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[5]);
}

// ===================================================================

class SockAddr::_Internal {
 public:
  static const ::SockAddrGeneric& sockaddr_generic(const SockAddr* msg);
  static const ::SockAddr4& sockaddr4(const SockAddr* msg);
  static const ::SockAddr6& sockaddr6(const SockAddr* msg);
};

const ::SockAddrGeneric&
SockAddr::_Internal::sockaddr_generic(const SockAddr* msg) {
  return *msg->sockaddr_.sockaddr_generic_;
}
const ::SockAddr4&
SockAddr::_Internal::sockaddr4(const SockAddr* msg) {
  return *msg->sockaddr_.sockaddr4_;
}
const ::SockAddr6&
SockAddr::_Internal::sockaddr6(const SockAddr* msg) {
  return *msg->sockaddr_.sockaddr6_;
}
void SockAddr::set_allocated_sockaddr_generic(::SockAddrGeneric* sockaddr_generic) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_sockaddr();
  if (sockaddr_generic) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::SockAddrGeneric>::GetOwningArena(sockaddr_generic);
    if (message_arena != submessage_arena) {
      sockaddr_generic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sockaddr_generic, submessage_arena);
    }
    set_has_sockaddr_generic();
    sockaddr_.sockaddr_generic_ = sockaddr_generic;
  }
  // @@protoc_insertion_point(field_set_allocated:SockAddr.sockaddr_generic)
}
void SockAddr::set_allocated_sockaddr4(::SockAddr4* sockaddr4) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_sockaddr();
  if (sockaddr4) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::SockAddr4>::GetOwningArena(sockaddr4);
    if (message_arena != submessage_arena) {
      sockaddr4 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sockaddr4, submessage_arena);
    }
    set_has_sockaddr4();
    sockaddr_.sockaddr4_ = sockaddr4;
  }
  // @@protoc_insertion_point(field_set_allocated:SockAddr.sockaddr4)
}
void SockAddr::set_allocated_sockaddr6(::SockAddr6* sockaddr6) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_sockaddr();
  if (sockaddr6) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::SockAddr6>::GetOwningArena(sockaddr6);
    if (message_arena != submessage_arena) {
      sockaddr6 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sockaddr6, submessage_arena);
    }
    set_has_sockaddr6();
    sockaddr_.sockaddr6_ = sockaddr6;
  }
  // @@protoc_insertion_point(field_set_allocated:SockAddr.sockaddr6)
}
SockAddr::SockAddr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:SockAddr)
}
SockAddr::SockAddr(const SockAddr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_sockaddr();
  switch (from.sockaddr_case()) {
    case kSockaddrGeneric: {
      _internal_mutable_sockaddr_generic()->::SockAddrGeneric::MergeFrom(from._internal_sockaddr_generic());
      break;
    }
    case kSockaddr4: {
      _internal_mutable_sockaddr4()->::SockAddr4::MergeFrom(from._internal_sockaddr4());
      break;
    }
    case kSockaddr6: {
      _internal_mutable_sockaddr6()->::SockAddr6::MergeFrom(from._internal_sockaddr6());
      break;
    }
    case SOCKADDR_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:SockAddr)
}

void SockAddr::SharedCtor() {
clear_has_sockaddr();
}

SockAddr::~SockAddr() {
  // @@protoc_insertion_point(destructor:SockAddr)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void SockAddr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_sockaddr()) {
    clear_sockaddr();
  }
}

void SockAddr::ArenaDtor(void* object) {
  SockAddr* _this = reinterpret_cast< SockAddr* >(object);
  (void)_this;
}
void SockAddr::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SockAddr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SockAddr::clear_sockaddr() {
// @@protoc_insertion_point(one_of_clear_start:SockAddr)
  switch (sockaddr_case()) {
    case kSockaddrGeneric: {
      if (GetArenaForAllocation() == nullptr) {
        delete sockaddr_.sockaddr_generic_;
      }
      break;
    }
    case kSockaddr4: {
      if (GetArenaForAllocation() == nullptr) {
        delete sockaddr_.sockaddr4_;
      }
      break;
    }
    case kSockaddr6: {
      if (GetArenaForAllocation() == nullptr) {
        delete sockaddr_.sockaddr6_;
      }
      break;
    }
    case SOCKADDR_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = SOCKADDR_NOT_SET;
}


void SockAddr::Clear() {
// @@protoc_insertion_point(message_clear_start:SockAddr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_sockaddr();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* SockAddr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .SockAddrGeneric sockaddr_generic = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_sockaddr_generic(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .SockAddr4 sockaddr4 = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_sockaddr4(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .SockAddr6 sockaddr6 = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_sockaddr6(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SockAddr::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SockAddr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (sockaddr_case()) {
    case kSockaddrGeneric: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::sockaddr_generic(this), target, stream);
      break;
    }
    case kSockaddr4: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          2, _Internal::sockaddr4(this), target, stream);
      break;
    }
    case kSockaddr6: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::sockaddr6(this), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SockAddr)
  return target;
}

size_t SockAddr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SockAddr)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (sockaddr_case()) {
    // .SockAddrGeneric sockaddr_generic = 1;
    case kSockaddrGeneric: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *sockaddr_.sockaddr_generic_);
      break;
    }
    // .SockAddr4 sockaddr4 = 2;
    case kSockaddr4: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *sockaddr_.sockaddr4_);
      break;
    }
    // .SockAddr6 sockaddr6 = 3;
    case kSockaddr6: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *sockaddr_.sockaddr6_);
      break;
    }
    case SOCKADDR_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SockAddr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    SockAddr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SockAddr::GetClassData() const { return &_class_data_; }

void SockAddr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<SockAddr *>(to)->MergeFrom(
      static_cast<const SockAddr &>(from));
}


void SockAddr::MergeFrom(const SockAddr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SockAddr)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.sockaddr_case()) {
    case kSockaddrGeneric: {
      _internal_mutable_sockaddr_generic()->::SockAddrGeneric::MergeFrom(from._internal_sockaddr_generic());
      break;
    }
    case kSockaddr4: {
      _internal_mutable_sockaddr4()->::SockAddr4::MergeFrom(from._internal_sockaddr4());
      break;
    }
    case kSockaddr6: {
      _internal_mutable_sockaddr6()->::SockAddr6::MergeFrom(from._internal_sockaddr6());
      break;
    }
    case SOCKADDR_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void SockAddr::CopyFrom(const SockAddr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:SockAddr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SockAddr::IsInitialized() const {
  switch (sockaddr_case()) {
    case kSockaddrGeneric: {
      if (has_sockaddr_generic()) {
        if (!this->sockaddr_generic().IsInitialized()) return false;
      }
      break;
    }
    case kSockaddr4: {
      if (has_sockaddr4()) {
        if (!this->sockaddr4().IsInitialized()) return false;
      }
      break;
    }
    case kSockaddr6: {
      if (has_sockaddr6()) {
        if (!this->sockaddr6().IsInitialized()) return false;
      }
      break;
    }
    case SOCKADDR_NOT_SET: {
      break;
    }
  }
  return true;
}

void SockAddr::InternalSwap(SockAddr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(sockaddr_, other->sockaddr_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata SockAddr::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[6]);
}

// ===================================================================

class SockAddrGeneric::_Internal {
 public:
  using HasBits = decltype(std::declval<SockAddrGeneric>()._has_bits_);
  static void set_has_sa_family(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_sa_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

SockAddrGeneric::SockAddrGeneric(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:SockAddrGeneric)
}
SockAddrGeneric::SockAddrGeneric(const SockAddrGeneric& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  sa_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_sa_data()) {
    sa_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_sa_data(), 
      GetArenaForAllocation());
  }
  sa_family_ = from.sa_family_;
  // @@protoc_insertion_point(copy_constructor:SockAddrGeneric)
}

void SockAddrGeneric::SharedCtor() {
sa_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
sa_family_ = 0;
}

SockAddrGeneric::~SockAddrGeneric() {
  // @@protoc_insertion_point(destructor:SockAddrGeneric)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void SockAddrGeneric::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  sa_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void SockAddrGeneric::ArenaDtor(void* object) {
  SockAddrGeneric* _this = reinterpret_cast< SockAddrGeneric* >(object);
  (void)_this;
}
void SockAddrGeneric::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SockAddrGeneric::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SockAddrGeneric::Clear() {
// @@protoc_insertion_point(message_clear_start:SockAddrGeneric)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    sa_data_.ClearNonDefaultToEmpty();
  }
  sa_family_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* SockAddrGeneric::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .Domain sa_family = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Domain_IsValid(val))) {
            _internal_set_sa_family(static_cast<::Domain>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required bytes sa_data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_sa_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SockAddrGeneric::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SockAddrGeneric)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .Domain sa_family = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_sa_family(), target);
  }

  // required bytes sa_data = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_sa_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SockAddrGeneric)
  return target;
}

size_t SockAddrGeneric::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:SockAddrGeneric)
  size_t total_size = 0;

  if (_internal_has_sa_data()) {
    // required bytes sa_data = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_sa_data());
  }

  if (_internal_has_sa_family()) {
    // required .Domain sa_family = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sa_family());
  }

  return total_size;
}
size_t SockAddrGeneric::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SockAddrGeneric)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required bytes sa_data = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_sa_data());

    // required .Domain sa_family = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sa_family());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SockAddrGeneric::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    SockAddrGeneric::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SockAddrGeneric::GetClassData() const { return &_class_data_; }

void SockAddrGeneric::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<SockAddrGeneric *>(to)->MergeFrom(
      static_cast<const SockAddrGeneric &>(from));
}


void SockAddrGeneric::MergeFrom(const SockAddrGeneric& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SockAddrGeneric)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_sa_data(from._internal_sa_data());
    }
    if (cached_has_bits & 0x00000002u) {
      sa_family_ = from.sa_family_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void SockAddrGeneric::CopyFrom(const SockAddrGeneric& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:SockAddrGeneric)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SockAddrGeneric::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void SockAddrGeneric::InternalSwap(SockAddrGeneric* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &sa_data_, lhs_arena,
      &other->sa_data_, rhs_arena
  );
  swap(sa_family_, other->sa_family_);
}

::PROTOBUF_NAMESPACE_ID::Metadata SockAddrGeneric::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[7]);
}

// ===================================================================

class SockAddr4::_Internal {
 public:
  using HasBits = decltype(std::declval<SockAddr4>()._has_bits_);
  static void set_has_sin_family(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_sin_port(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_sin_addr(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
  }
};

SockAddr4::SockAddr4(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:SockAddr4)
}
SockAddr4::SockAddr4(const SockAddr4& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&sin_family_, &from.sin_family_,
    static_cast<size_t>(reinterpret_cast<char*>(&sin_addr_) -
    reinterpret_cast<char*>(&sin_family_)) + sizeof(sin_addr_));
  // @@protoc_insertion_point(copy_constructor:SockAddr4)
}

void SockAddr4::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&sin_family_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&sin_addr_) -
    reinterpret_cast<char*>(&sin_family_)) + sizeof(sin_addr_));
}

SockAddr4::~SockAddr4() {
  // @@protoc_insertion_point(destructor:SockAddr4)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void SockAddr4::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void SockAddr4::ArenaDtor(void* object) {
  SockAddr4* _this = reinterpret_cast< SockAddr4* >(object);
  (void)_this;
}
void SockAddr4::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SockAddr4::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SockAddr4::Clear() {
// @@protoc_insertion_point(message_clear_start:SockAddr4)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&sin_family_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&sin_addr_) -
        reinterpret_cast<char*>(&sin_family_)) + sizeof(sin_addr_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* SockAddr4::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .Domain sin_family = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Domain_IsValid(val))) {
            _internal_set_sin_family(static_cast<::Domain>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .Port sin_port = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Port_IsValid(val))) {
            _internal_set_sin_port(static_cast<::Port>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .InAddr sin_addr = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::InAddr_IsValid(val))) {
            _internal_set_sin_addr(static_cast<::InAddr>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SockAddr4::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SockAddr4)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .Domain sin_family = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_sin_family(), target);
  }

  // required .Port sin_port = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_sin_port(), target);
  }

  // required .InAddr sin_addr = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_sin_addr(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SockAddr4)
  return target;
}

size_t SockAddr4::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:SockAddr4)
  size_t total_size = 0;

  if (_internal_has_sin_family()) {
    // required .Domain sin_family = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sin_family());
  }

  if (_internal_has_sin_port()) {
    // required .Port sin_port = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sin_port());
  }

  if (_internal_has_sin_addr()) {
    // required .InAddr sin_addr = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sin_addr());
  }

  return total_size;
}
size_t SockAddr4::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SockAddr4)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required .Domain sin_family = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sin_family());

    // required .Port sin_port = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sin_port());

    // required .InAddr sin_addr = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sin_addr());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SockAddr4::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    SockAddr4::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SockAddr4::GetClassData() const { return &_class_data_; }

void SockAddr4::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<SockAddr4 *>(to)->MergeFrom(
      static_cast<const SockAddr4 &>(from));
}


void SockAddr4::MergeFrom(const SockAddr4& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SockAddr4)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      sin_family_ = from.sin_family_;
    }
    if (cached_has_bits & 0x00000002u) {
      sin_port_ = from.sin_port_;
    }
    if (cached_has_bits & 0x00000004u) {
      sin_addr_ = from.sin_addr_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void SockAddr4::CopyFrom(const SockAddr4& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:SockAddr4)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SockAddr4::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void SockAddr4::InternalSwap(SockAddr4* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SockAddr4, sin_addr_)
      + sizeof(SockAddr4::sin_addr_)
      - PROTOBUF_FIELD_OFFSET(SockAddr4, sin_family_)>(
          reinterpret_cast<char*>(&sin_family_),
          reinterpret_cast<char*>(&other->sin_family_));
}

::PROTOBUF_NAMESPACE_ID::Metadata SockAddr4::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[8]);
}

// ===================================================================

class SockAddr6::_Internal {
 public:
  using HasBits = decltype(std::declval<SockAddr6>()._has_bits_);
  static void set_has_family(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_port(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_flow_info(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_sin6_addr(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_sin6_scope_id(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000001f) ^ 0x0000001f) != 0;
  }
};

SockAddr6::SockAddr6(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:SockAddr6)
}
SockAddr6::SockAddr6(const SockAddr6& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&family_, &from.family_,
    static_cast<size_t>(reinterpret_cast<char*>(&sin6_scope_id_) -
    reinterpret_cast<char*>(&family_)) + sizeof(sin6_scope_id_));
  // @@protoc_insertion_point(copy_constructor:SockAddr6)
}

void SockAddr6::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&family_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&sin6_scope_id_) -
    reinterpret_cast<char*>(&family_)) + sizeof(sin6_scope_id_));
}

SockAddr6::~SockAddr6() {
  // @@protoc_insertion_point(destructor:SockAddr6)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void SockAddr6::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void SockAddr6::ArenaDtor(void* object) {
  SockAddr6* _this = reinterpret_cast< SockAddr6* >(object);
  (void)_this;
}
void SockAddr6::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SockAddr6::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SockAddr6::Clear() {
// @@protoc_insertion_point(message_clear_start:SockAddr6)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    ::memset(&family_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&sin6_scope_id_) -
        reinterpret_cast<char*>(&family_)) + sizeof(sin6_scope_id_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* SockAddr6::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .Domain family = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Domain_IsValid(val))) {
            _internal_set_family(static_cast<::Domain>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .Port port = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Port_IsValid(val))) {
            _internal_set_port(static_cast<::Port>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .FlowInfo flow_info = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FlowInfo_IsValid(val))) {
            _internal_set_flow_info(static_cast<::FlowInfo>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .In6Addr sin6_addr = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::In6Addr_IsValid(val))) {
            _internal_set_sin6_addr(static_cast<::In6Addr>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .ScopeId sin6_scope_id = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::ScopeId_IsValid(val))) {
            _internal_set_sin6_scope_id(static_cast<::ScopeId>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SockAddr6::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SockAddr6)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .Domain family = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_family(), target);
  }

  // required .Port port = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_port(), target);
  }

  // required .FlowInfo flow_info = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_flow_info(), target);
  }

  // required .In6Addr sin6_addr = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      4, this->_internal_sin6_addr(), target);
  }

  // required .ScopeId sin6_scope_id = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      5, this->_internal_sin6_scope_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SockAddr6)
  return target;
}

size_t SockAddr6::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:SockAddr6)
  size_t total_size = 0;

  if (_internal_has_family()) {
    // required .Domain family = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_family());
  }

  if (_internal_has_port()) {
    // required .Port port = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_port());
  }

  if (_internal_has_flow_info()) {
    // required .FlowInfo flow_info = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_flow_info());
  }

  if (_internal_has_sin6_addr()) {
    // required .In6Addr sin6_addr = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sin6_addr());
  }

  if (_internal_has_sin6_scope_id()) {
    // required .ScopeId sin6_scope_id = 5;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sin6_scope_id());
  }

  return total_size;
}
size_t SockAddr6::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SockAddr6)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x0000001f) ^ 0x0000001f) == 0) {  // All required fields are present.
    // required .Domain family = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_family());

    // required .Port port = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_port());

    // required .FlowInfo flow_info = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_flow_info());

    // required .In6Addr sin6_addr = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sin6_addr());

    // required .ScopeId sin6_scope_id = 5;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sin6_scope_id());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SockAddr6::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    SockAddr6::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SockAddr6::GetClassData() const { return &_class_data_; }

void SockAddr6::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<SockAddr6 *>(to)->MergeFrom(
      static_cast<const SockAddr6 &>(from));
}


void SockAddr6::MergeFrom(const SockAddr6& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SockAddr6)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      family_ = from.family_;
    }
    if (cached_has_bits & 0x00000002u) {
      port_ = from.port_;
    }
    if (cached_has_bits & 0x00000004u) {
      flow_info_ = from.flow_info_;
    }
    if (cached_has_bits & 0x00000008u) {
      sin6_addr_ = from.sin6_addr_;
    }
    if (cached_has_bits & 0x00000010u) {
      sin6_scope_id_ = from.sin6_scope_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void SockAddr6::CopyFrom(const SockAddr6& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:SockAddr6)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SockAddr6::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void SockAddr6::InternalSwap(SockAddr6* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SockAddr6, sin6_scope_id_)
      + sizeof(SockAddr6::sin6_scope_id_)
      - PROTOBUF_FIELD_OFFSET(SockAddr6, family_)>(
          reinterpret_cast<char*>(&family_),
          reinterpret_cast<char*>(&other->family_));
}

::PROTOBUF_NAMESPACE_ID::Metadata SockAddr6::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[9]);
}

// ===================================================================

class Command::_Internal {
 public:
  static const ::Packet& ip_input(const Command* msg);
  static const ::Ioctl& ioctl(const Command* msg);
  static const ::SetSocketOpt& set_sock_opt(const Command* msg);
  static const ::IoctlReal& ioctl_real(const Command* msg);
  static const ::ConnectX& connectx(const Command* msg);
  static const ::Connect& connect(const Command* msg);
  static const ::Listen& listen(const Command* msg);
  static const ::DisconnectX& disconnectx(const Command* msg);
  static const ::GetSocketOpt& get_sock_opt(const Command* msg);
  static const ::Bind& bind(const Command* msg);
  static const ::Accept& accept(const Command* msg);
  static const ::Socket& socket(const Command* msg);
  static const ::Close& close(const Command* msg);
  static const ::ClearAll& clear_all(const Command* msg);
  static const ::NecpMatchPolicy& necp_match_policy(const Command* msg);
  static const ::NecpOpen& necp_open(const Command* msg);
  static const ::NecpClientAction& necp_client_action(const Command* msg);
  static const ::NecpSessionOpen& necp_session_open(const Command* msg);
  static const ::NecpSessionAction& necp_session_action(const Command* msg);
  static const ::AcceptNocancel& accept_nocancel(const Command* msg);
  static const ::ConnectNocancel& connect_nocancel(const Command* msg);
  static const ::Getpeername& getpeername(const Command* msg);
  static const ::Getsockname& getsockname(const Command* msg);
  static const ::Peeloff& peeloff(const Command* msg);
  static const ::Recvfrom& recvfrom(const Command* msg);
  static const ::RecvfromNocancel& recvfrom_nocancel(const Command* msg);
  static const ::Recvmsg& recvmsg(const Command* msg);
  static const ::Sendto& sendto(const Command* msg);
  static const ::Socketpair& socketpair(const Command* msg);
  static const ::Pipe& pipe(const Command* msg);
  static const ::Shutdown& shutdown(const Command* msg);
};

const ::Packet&
Command::_Internal::ip_input(const Command* msg) {
  return *msg->command_.ip_input_;
}
const ::Ioctl&
Command::_Internal::ioctl(const Command* msg) {
  return *msg->command_.ioctl_;
}
const ::SetSocketOpt&
Command::_Internal::set_sock_opt(const Command* msg) {
  return *msg->command_.set_sock_opt_;
}
const ::IoctlReal&
Command::_Internal::ioctl_real(const Command* msg) {
  return *msg->command_.ioctl_real_;
}
const ::ConnectX&
Command::_Internal::connectx(const Command* msg) {
  return *msg->command_.connectx_;
}
const ::Connect&
Command::_Internal::connect(const Command* msg) {
  return *msg->command_.connect_;
}
const ::Listen&
Command::_Internal::listen(const Command* msg) {
  return *msg->command_.listen_;
}
const ::DisconnectX&
Command::_Internal::disconnectx(const Command* msg) {
  return *msg->command_.disconnectx_;
}
const ::GetSocketOpt&
Command::_Internal::get_sock_opt(const Command* msg) {
  return *msg->command_.get_sock_opt_;
}
const ::Bind&
Command::_Internal::bind(const Command* msg) {
  return *msg->command_.bind_;
}
const ::Accept&
Command::_Internal::accept(const Command* msg) {
  return *msg->command_.accept_;
}
const ::Socket&
Command::_Internal::socket(const Command* msg) {
  return *msg->command_.socket_;
}
const ::Close&
Command::_Internal::close(const Command* msg) {
  return *msg->command_.close_;
}
const ::ClearAll&
Command::_Internal::clear_all(const Command* msg) {
  return *msg->command_.clear_all_;
}
const ::NecpMatchPolicy&
Command::_Internal::necp_match_policy(const Command* msg) {
  return *msg->command_.necp_match_policy_;
}
const ::NecpOpen&
Command::_Internal::necp_open(const Command* msg) {
  return *msg->command_.necp_open_;
}
const ::NecpClientAction&
Command::_Internal::necp_client_action(const Command* msg) {
  return *msg->command_.necp_client_action_;
}
const ::NecpSessionOpen&
Command::_Internal::necp_session_open(const Command* msg) {
  return *msg->command_.necp_session_open_;
}
const ::NecpSessionAction&
Command::_Internal::necp_session_action(const Command* msg) {
  return *msg->command_.necp_session_action_;
}
const ::AcceptNocancel&
Command::_Internal::accept_nocancel(const Command* msg) {
  return *msg->command_.accept_nocancel_;
}
const ::ConnectNocancel&
Command::_Internal::connect_nocancel(const Command* msg) {
  return *msg->command_.connect_nocancel_;
}
const ::Getpeername&
Command::_Internal::getpeername(const Command* msg) {
  return *msg->command_.getpeername_;
}
const ::Getsockname&
Command::_Internal::getsockname(const Command* msg) {
  return *msg->command_.getsockname_;
}
const ::Peeloff&
Command::_Internal::peeloff(const Command* msg) {
  return *msg->command_.peeloff_;
}
const ::Recvfrom&
Command::_Internal::recvfrom(const Command* msg) {
  return *msg->command_.recvfrom_;
}
const ::RecvfromNocancel&
Command::_Internal::recvfrom_nocancel(const Command* msg) {
  return *msg->command_.recvfrom_nocancel_;
}
const ::Recvmsg&
Command::_Internal::recvmsg(const Command* msg) {
  return *msg->command_.recvmsg_;
}
const ::Sendto&
Command::_Internal::sendto(const Command* msg) {
  return *msg->command_.sendto_;
}
const ::Socketpair&
Command::_Internal::socketpair(const Command* msg) {
  return *msg->command_.socketpair_;
}
const ::Pipe&
Command::_Internal::pipe(const Command* msg) {
  return *msg->command_.pipe_;
}
const ::Shutdown&
Command::_Internal::shutdown(const Command* msg) {
  return *msg->command_.shutdown_;
}
void Command::set_allocated_ip_input(::Packet* ip_input) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (ip_input) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Packet>::GetOwningArena(ip_input);
    if (message_arena != submessage_arena) {
      ip_input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ip_input, submessage_arena);
    }
    set_has_ip_input();
    command_.ip_input_ = ip_input;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.ip_input)
}
void Command::set_allocated_ioctl(::Ioctl* ioctl) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (ioctl) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Ioctl>::GetOwningArena(ioctl);
    if (message_arena != submessage_arena) {
      ioctl = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ioctl, submessage_arena);
    }
    set_has_ioctl();
    command_.ioctl_ = ioctl;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.ioctl)
}
void Command::set_allocated_set_sock_opt(::SetSocketOpt* set_sock_opt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (set_sock_opt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::SetSocketOpt>::GetOwningArena(set_sock_opt);
    if (message_arena != submessage_arena) {
      set_sock_opt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_sock_opt, submessage_arena);
    }
    set_has_set_sock_opt();
    command_.set_sock_opt_ = set_sock_opt;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.set_sock_opt)
}
void Command::set_allocated_ioctl_real(::IoctlReal* ioctl_real) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (ioctl_real) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::IoctlReal>::GetOwningArena(ioctl_real);
    if (message_arena != submessage_arena) {
      ioctl_real = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ioctl_real, submessage_arena);
    }
    set_has_ioctl_real();
    command_.ioctl_real_ = ioctl_real;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.ioctl_real)
}
void Command::set_allocated_connectx(::ConnectX* connectx) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (connectx) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::ConnectX>::GetOwningArena(connectx);
    if (message_arena != submessage_arena) {
      connectx = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, connectx, submessage_arena);
    }
    set_has_connectx();
    command_.connectx_ = connectx;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.connectx)
}
void Command::set_allocated_connect(::Connect* connect) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (connect) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Connect>::GetOwningArena(connect);
    if (message_arena != submessage_arena) {
      connect = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, connect, submessage_arena);
    }
    set_has_connect();
    command_.connect_ = connect;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.connect)
}
void Command::set_allocated_listen(::Listen* listen) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (listen) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Listen>::GetOwningArena(listen);
    if (message_arena != submessage_arena) {
      listen = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, listen, submessage_arena);
    }
    set_has_listen();
    command_.listen_ = listen;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.listen)
}
void Command::set_allocated_disconnectx(::DisconnectX* disconnectx) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (disconnectx) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::DisconnectX>::GetOwningArena(disconnectx);
    if (message_arena != submessage_arena) {
      disconnectx = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, disconnectx, submessage_arena);
    }
    set_has_disconnectx();
    command_.disconnectx_ = disconnectx;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.disconnectx)
}
void Command::set_allocated_get_sock_opt(::GetSocketOpt* get_sock_opt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (get_sock_opt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::GetSocketOpt>::GetOwningArena(get_sock_opt);
    if (message_arena != submessage_arena) {
      get_sock_opt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, get_sock_opt, submessage_arena);
    }
    set_has_get_sock_opt();
    command_.get_sock_opt_ = get_sock_opt;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.get_sock_opt)
}
void Command::set_allocated_bind(::Bind* bind) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (bind) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Bind>::GetOwningArena(bind);
    if (message_arena != submessage_arena) {
      bind = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bind, submessage_arena);
    }
    set_has_bind();
    command_.bind_ = bind;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.bind)
}
void Command::set_allocated_accept(::Accept* accept) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (accept) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Accept>::GetOwningArena(accept);
    if (message_arena != submessage_arena) {
      accept = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, accept, submessage_arena);
    }
    set_has_accept();
    command_.accept_ = accept;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.accept)
}
void Command::set_allocated_socket(::Socket* socket) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (socket) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Socket>::GetOwningArena(socket);
    if (message_arena != submessage_arena) {
      socket = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, socket, submessage_arena);
    }
    set_has_socket();
    command_.socket_ = socket;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.socket)
}
void Command::set_allocated_close(::Close* close) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (close) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Close>::GetOwningArena(close);
    if (message_arena != submessage_arena) {
      close = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, close, submessage_arena);
    }
    set_has_close();
    command_.close_ = close;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.close)
}
void Command::set_allocated_clear_all(::ClearAll* clear_all) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (clear_all) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::ClearAll>::GetOwningArena(clear_all);
    if (message_arena != submessage_arena) {
      clear_all = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, clear_all, submessage_arena);
    }
    set_has_clear_all();
    command_.clear_all_ = clear_all;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.clear_all)
}
void Command::set_allocated_necp_match_policy(::NecpMatchPolicy* necp_match_policy) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (necp_match_policy) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::NecpMatchPolicy>::GetOwningArena(necp_match_policy);
    if (message_arena != submessage_arena) {
      necp_match_policy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, necp_match_policy, submessage_arena);
    }
    set_has_necp_match_policy();
    command_.necp_match_policy_ = necp_match_policy;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.necp_match_policy)
}
void Command::set_allocated_necp_open(::NecpOpen* necp_open) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (necp_open) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::NecpOpen>::GetOwningArena(necp_open);
    if (message_arena != submessage_arena) {
      necp_open = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, necp_open, submessage_arena);
    }
    set_has_necp_open();
    command_.necp_open_ = necp_open;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.necp_open)
}
void Command::set_allocated_necp_client_action(::NecpClientAction* necp_client_action) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (necp_client_action) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::NecpClientAction>::GetOwningArena(necp_client_action);
    if (message_arena != submessage_arena) {
      necp_client_action = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, necp_client_action, submessage_arena);
    }
    set_has_necp_client_action();
    command_.necp_client_action_ = necp_client_action;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.necp_client_action)
}
void Command::set_allocated_necp_session_open(::NecpSessionOpen* necp_session_open) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (necp_session_open) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::NecpSessionOpen>::GetOwningArena(necp_session_open);
    if (message_arena != submessage_arena) {
      necp_session_open = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, necp_session_open, submessage_arena);
    }
    set_has_necp_session_open();
    command_.necp_session_open_ = necp_session_open;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.necp_session_open)
}
void Command::set_allocated_necp_session_action(::NecpSessionAction* necp_session_action) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (necp_session_action) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::NecpSessionAction>::GetOwningArena(necp_session_action);
    if (message_arena != submessage_arena) {
      necp_session_action = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, necp_session_action, submessage_arena);
    }
    set_has_necp_session_action();
    command_.necp_session_action_ = necp_session_action;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.necp_session_action)
}
void Command::set_allocated_accept_nocancel(::AcceptNocancel* accept_nocancel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (accept_nocancel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::AcceptNocancel>::GetOwningArena(accept_nocancel);
    if (message_arena != submessage_arena) {
      accept_nocancel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, accept_nocancel, submessage_arena);
    }
    set_has_accept_nocancel();
    command_.accept_nocancel_ = accept_nocancel;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.accept_nocancel)
}
void Command::set_allocated_connect_nocancel(::ConnectNocancel* connect_nocancel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (connect_nocancel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::ConnectNocancel>::GetOwningArena(connect_nocancel);
    if (message_arena != submessage_arena) {
      connect_nocancel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, connect_nocancel, submessage_arena);
    }
    set_has_connect_nocancel();
    command_.connect_nocancel_ = connect_nocancel;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.connect_nocancel)
}
void Command::set_allocated_getpeername(::Getpeername* getpeername) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (getpeername) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Getpeername>::GetOwningArena(getpeername);
    if (message_arena != submessage_arena) {
      getpeername = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, getpeername, submessage_arena);
    }
    set_has_getpeername();
    command_.getpeername_ = getpeername;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.getpeername)
}
void Command::set_allocated_getsockname(::Getsockname* getsockname) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (getsockname) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Getsockname>::GetOwningArena(getsockname);
    if (message_arena != submessage_arena) {
      getsockname = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, getsockname, submessage_arena);
    }
    set_has_getsockname();
    command_.getsockname_ = getsockname;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.getsockname)
}
void Command::set_allocated_peeloff(::Peeloff* peeloff) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (peeloff) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Peeloff>::GetOwningArena(peeloff);
    if (message_arena != submessage_arena) {
      peeloff = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, peeloff, submessage_arena);
    }
    set_has_peeloff();
    command_.peeloff_ = peeloff;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.peeloff)
}
void Command::set_allocated_recvfrom(::Recvfrom* recvfrom) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (recvfrom) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Recvfrom>::GetOwningArena(recvfrom);
    if (message_arena != submessage_arena) {
      recvfrom = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, recvfrom, submessage_arena);
    }
    set_has_recvfrom();
    command_.recvfrom_ = recvfrom;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.recvfrom)
}
void Command::set_allocated_recvfrom_nocancel(::RecvfromNocancel* recvfrom_nocancel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (recvfrom_nocancel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::RecvfromNocancel>::GetOwningArena(recvfrom_nocancel);
    if (message_arena != submessage_arena) {
      recvfrom_nocancel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, recvfrom_nocancel, submessage_arena);
    }
    set_has_recvfrom_nocancel();
    command_.recvfrom_nocancel_ = recvfrom_nocancel;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.recvfrom_nocancel)
}
void Command::set_allocated_recvmsg(::Recvmsg* recvmsg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (recvmsg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Recvmsg>::GetOwningArena(recvmsg);
    if (message_arena != submessage_arena) {
      recvmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, recvmsg, submessage_arena);
    }
    set_has_recvmsg();
    command_.recvmsg_ = recvmsg;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.recvmsg)
}
void Command::set_allocated_sendto(::Sendto* sendto) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (sendto) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Sendto>::GetOwningArena(sendto);
    if (message_arena != submessage_arena) {
      sendto = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sendto, submessage_arena);
    }
    set_has_sendto();
    command_.sendto_ = sendto;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.sendto)
}
void Command::set_allocated_socketpair(::Socketpair* socketpair) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (socketpair) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Socketpair>::GetOwningArena(socketpair);
    if (message_arena != submessage_arena) {
      socketpair = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, socketpair, submessage_arena);
    }
    set_has_socketpair();
    command_.socketpair_ = socketpair;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.socketpair)
}
void Command::set_allocated_pipe(::Pipe* pipe) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (pipe) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Pipe>::GetOwningArena(pipe);
    if (message_arena != submessage_arena) {
      pipe = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pipe, submessage_arena);
    }
    set_has_pipe();
    command_.pipe_ = pipe;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.pipe)
}
void Command::set_allocated_shutdown(::Shutdown* shutdown) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_command();
  if (shutdown) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Shutdown>::GetOwningArena(shutdown);
    if (message_arena != submessage_arena) {
      shutdown = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, shutdown, submessage_arena);
    }
    set_has_shutdown();
    command_.shutdown_ = shutdown;
  }
  // @@protoc_insertion_point(field_set_allocated:Command.shutdown)
}
Command::Command(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Command)
}
Command::Command(const Command& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_command();
  switch (from.command_case()) {
    case kIpInput: {
      _internal_mutable_ip_input()->::Packet::MergeFrom(from._internal_ip_input());
      break;
    }
    case kIoctl: {
      _internal_mutable_ioctl()->::Ioctl::MergeFrom(from._internal_ioctl());
      break;
    }
    case kSetSockOpt: {
      _internal_mutable_set_sock_opt()->::SetSocketOpt::MergeFrom(from._internal_set_sock_opt());
      break;
    }
    case kIoctlReal: {
      _internal_mutable_ioctl_real()->::IoctlReal::MergeFrom(from._internal_ioctl_real());
      break;
    }
    case kConnectx: {
      _internal_mutable_connectx()->::ConnectX::MergeFrom(from._internal_connectx());
      break;
    }
    case kConnect: {
      _internal_mutable_connect()->::Connect::MergeFrom(from._internal_connect());
      break;
    }
    case kListen: {
      _internal_mutable_listen()->::Listen::MergeFrom(from._internal_listen());
      break;
    }
    case kDisconnectx: {
      _internal_mutable_disconnectx()->::DisconnectX::MergeFrom(from._internal_disconnectx());
      break;
    }
    case kGetSockOpt: {
      _internal_mutable_get_sock_opt()->::GetSocketOpt::MergeFrom(from._internal_get_sock_opt());
      break;
    }
    case kBind: {
      _internal_mutable_bind()->::Bind::MergeFrom(from._internal_bind());
      break;
    }
    case kAccept: {
      _internal_mutable_accept()->::Accept::MergeFrom(from._internal_accept());
      break;
    }
    case kSocket: {
      _internal_mutable_socket()->::Socket::MergeFrom(from._internal_socket());
      break;
    }
    case kClose: {
      _internal_mutable_close()->::Close::MergeFrom(from._internal_close());
      break;
    }
    case kClearAll: {
      _internal_mutable_clear_all()->::ClearAll::MergeFrom(from._internal_clear_all());
      break;
    }
    case kNecpMatchPolicy: {
      _internal_mutable_necp_match_policy()->::NecpMatchPolicy::MergeFrom(from._internal_necp_match_policy());
      break;
    }
    case kNecpOpen: {
      _internal_mutable_necp_open()->::NecpOpen::MergeFrom(from._internal_necp_open());
      break;
    }
    case kNecpClientAction: {
      _internal_mutable_necp_client_action()->::NecpClientAction::MergeFrom(from._internal_necp_client_action());
      break;
    }
    case kNecpSessionOpen: {
      _internal_mutable_necp_session_open()->::NecpSessionOpen::MergeFrom(from._internal_necp_session_open());
      break;
    }
    case kNecpSessionAction: {
      _internal_mutable_necp_session_action()->::NecpSessionAction::MergeFrom(from._internal_necp_session_action());
      break;
    }
    case kAcceptNocancel: {
      _internal_mutable_accept_nocancel()->::AcceptNocancel::MergeFrom(from._internal_accept_nocancel());
      break;
    }
    case kConnectNocancel: {
      _internal_mutable_connect_nocancel()->::ConnectNocancel::MergeFrom(from._internal_connect_nocancel());
      break;
    }
    case kGetpeername: {
      _internal_mutable_getpeername()->::Getpeername::MergeFrom(from._internal_getpeername());
      break;
    }
    case kGetsockname: {
      _internal_mutable_getsockname()->::Getsockname::MergeFrom(from._internal_getsockname());
      break;
    }
    case kPeeloff: {
      _internal_mutable_peeloff()->::Peeloff::MergeFrom(from._internal_peeloff());
      break;
    }
    case kRecvfrom: {
      _internal_mutable_recvfrom()->::Recvfrom::MergeFrom(from._internal_recvfrom());
      break;
    }
    case kRecvfromNocancel: {
      _internal_mutable_recvfrom_nocancel()->::RecvfromNocancel::MergeFrom(from._internal_recvfrom_nocancel());
      break;
    }
    case kRecvmsg: {
      _internal_mutable_recvmsg()->::Recvmsg::MergeFrom(from._internal_recvmsg());
      break;
    }
    case kSendto: {
      _internal_mutable_sendto()->::Sendto::MergeFrom(from._internal_sendto());
      break;
    }
    case kSocketpair: {
      _internal_mutable_socketpair()->::Socketpair::MergeFrom(from._internal_socketpair());
      break;
    }
    case kPipe: {
      _internal_mutable_pipe()->::Pipe::MergeFrom(from._internal_pipe());
      break;
    }
    case kShutdown: {
      _internal_mutable_shutdown()->::Shutdown::MergeFrom(from._internal_shutdown());
      break;
    }
    case COMMAND_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:Command)
}

void Command::SharedCtor() {
clear_has_command();
}

Command::~Command() {
  // @@protoc_insertion_point(destructor:Command)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Command::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_command()) {
    clear_command();
  }
}

void Command::ArenaDtor(void* object) {
  Command* _this = reinterpret_cast< Command* >(object);
  (void)_this;
}
void Command::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Command::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Command::clear_command() {
// @@protoc_insertion_point(one_of_clear_start:Command)
  switch (command_case()) {
    case kIpInput: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.ip_input_;
      }
      break;
    }
    case kIoctl: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.ioctl_;
      }
      break;
    }
    case kSetSockOpt: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.set_sock_opt_;
      }
      break;
    }
    case kIoctlReal: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.ioctl_real_;
      }
      break;
    }
    case kConnectx: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.connectx_;
      }
      break;
    }
    case kConnect: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.connect_;
      }
      break;
    }
    case kListen: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.listen_;
      }
      break;
    }
    case kDisconnectx: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.disconnectx_;
      }
      break;
    }
    case kGetSockOpt: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.get_sock_opt_;
      }
      break;
    }
    case kBind: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.bind_;
      }
      break;
    }
    case kAccept: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.accept_;
      }
      break;
    }
    case kSocket: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.socket_;
      }
      break;
    }
    case kClose: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.close_;
      }
      break;
    }
    case kClearAll: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.clear_all_;
      }
      break;
    }
    case kNecpMatchPolicy: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.necp_match_policy_;
      }
      break;
    }
    case kNecpOpen: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.necp_open_;
      }
      break;
    }
    case kNecpClientAction: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.necp_client_action_;
      }
      break;
    }
    case kNecpSessionOpen: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.necp_session_open_;
      }
      break;
    }
    case kNecpSessionAction: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.necp_session_action_;
      }
      break;
    }
    case kAcceptNocancel: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.accept_nocancel_;
      }
      break;
    }
    case kConnectNocancel: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.connect_nocancel_;
      }
      break;
    }
    case kGetpeername: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.getpeername_;
      }
      break;
    }
    case kGetsockname: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.getsockname_;
      }
      break;
    }
    case kPeeloff: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.peeloff_;
      }
      break;
    }
    case kRecvfrom: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.recvfrom_;
      }
      break;
    }
    case kRecvfromNocancel: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.recvfrom_nocancel_;
      }
      break;
    }
    case kRecvmsg: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.recvmsg_;
      }
      break;
    }
    case kSendto: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.sendto_;
      }
      break;
    }
    case kSocketpair: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.socketpair_;
      }
      break;
    }
    case kPipe: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.pipe_;
      }
      break;
    }
    case kShutdown: {
      if (GetArenaForAllocation() == nullptr) {
        delete command_.shutdown_;
      }
      break;
    }
    case COMMAND_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = COMMAND_NOT_SET;
}


void Command::Clear() {
// @@protoc_insertion_point(message_clear_start:Command)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_command();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Command::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .Packet ip_input = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_ip_input(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Ioctl ioctl = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_ioctl(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .SetSocketOpt set_sock_opt = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_set_sock_opt(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .IoctlReal ioctl_real = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_ioctl_real(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .ConnectX connectx = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_connectx(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Connect connect = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_connect(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Listen listen = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_listen(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .DisconnectX disconnectx = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_disconnectx(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .GetSocketOpt get_sock_opt = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_get_sock_opt(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Bind bind = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_bind(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Accept accept = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_accept(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Socket socket = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
          ptr = ctx->ParseMessage(_internal_mutable_socket(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Close close = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
          ptr = ctx->ParseMessage(_internal_mutable_close(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .ClearAll clear_all = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
          ptr = ctx->ParseMessage(_internal_mutable_clear_all(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .NecpMatchPolicy necp_match_policy = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
          ptr = ctx->ParseMessage(_internal_mutable_necp_match_policy(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .NecpOpen necp_open = 17;
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) {
          ptr = ctx->ParseMessage(_internal_mutable_necp_open(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .NecpClientAction necp_client_action = 18;
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 146)) {
          ptr = ctx->ParseMessage(_internal_mutable_necp_client_action(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .NecpSessionOpen necp_session_open = 19;
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) {
          ptr = ctx->ParseMessage(_internal_mutable_necp_session_open(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .NecpSessionAction necp_session_action = 20;
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) {
          ptr = ctx->ParseMessage(_internal_mutable_necp_session_action(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .AcceptNocancel accept_nocancel = 21;
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
          ptr = ctx->ParseMessage(_internal_mutable_accept_nocancel(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .ConnectNocancel connect_nocancel = 22;
      case 22:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
          ptr = ctx->ParseMessage(_internal_mutable_connect_nocancel(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Getpeername getpeername = 23;
      case 23:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) {
          ptr = ctx->ParseMessage(_internal_mutable_getpeername(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Getsockname getsockname = 24;
      case 24:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) {
          ptr = ctx->ParseMessage(_internal_mutable_getsockname(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Peeloff peeloff = 25;
      case 25:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) {
          ptr = ctx->ParseMessage(_internal_mutable_peeloff(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Recvfrom recvfrom = 26;
      case 26:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 210)) {
          ptr = ctx->ParseMessage(_internal_mutable_recvfrom(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .RecvfromNocancel recvfrom_nocancel = 27;
      case 27:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) {
          ptr = ctx->ParseMessage(_internal_mutable_recvfrom_nocancel(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Recvmsg recvmsg = 28;
      case 28:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) {
          ptr = ctx->ParseMessage(_internal_mutable_recvmsg(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Sendto sendto = 34;
      case 34:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_sendto(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Socketpair socketpair = 38;
      case 38:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_socketpair(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Pipe pipe = 39;
      case 39:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_pipe(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Shutdown shutdown = 40;
      case 40:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_shutdown(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Command::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Command)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (command_case()) {
    case kIpInput: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::ip_input(this), target, stream);
      break;
    }
    case kIoctl: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::ioctl(this), target, stream);
      break;
    }
    case kSetSockOpt: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          4, _Internal::set_sock_opt(this), target, stream);
      break;
    }
    case kIoctlReal: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          5, _Internal::ioctl_real(this), target, stream);
      break;
    }
    case kConnectx: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          6, _Internal::connectx(this), target, stream);
      break;
    }
    case kConnect: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          7, _Internal::connect(this), target, stream);
      break;
    }
    case kListen: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          8, _Internal::listen(this), target, stream);
      break;
    }
    case kDisconnectx: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          9, _Internal::disconnectx(this), target, stream);
      break;
    }
    case kGetSockOpt: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          10, _Internal::get_sock_opt(this), target, stream);
      break;
    }
    case kBind: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          11, _Internal::bind(this), target, stream);
      break;
    }
    case kAccept: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          12, _Internal::accept(this), target, stream);
      break;
    }
    case kSocket: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          13, _Internal::socket(this), target, stream);
      break;
    }
    case kClose: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          14, _Internal::close(this), target, stream);
      break;
    }
    case kClearAll: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          15, _Internal::clear_all(this), target, stream);
      break;
    }
    case kNecpMatchPolicy: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          16, _Internal::necp_match_policy(this), target, stream);
      break;
    }
    case kNecpOpen: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          17, _Internal::necp_open(this), target, stream);
      break;
    }
    case kNecpClientAction: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          18, _Internal::necp_client_action(this), target, stream);
      break;
    }
    case kNecpSessionOpen: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          19, _Internal::necp_session_open(this), target, stream);
      break;
    }
    case kNecpSessionAction: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          20, _Internal::necp_session_action(this), target, stream);
      break;
    }
    case kAcceptNocancel: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          21, _Internal::accept_nocancel(this), target, stream);
      break;
    }
    case kConnectNocancel: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          22, _Internal::connect_nocancel(this), target, stream);
      break;
    }
    case kGetpeername: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          23, _Internal::getpeername(this), target, stream);
      break;
    }
    case kGetsockname: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          24, _Internal::getsockname(this), target, stream);
      break;
    }
    case kPeeloff: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          25, _Internal::peeloff(this), target, stream);
      break;
    }
    case kRecvfrom: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          26, _Internal::recvfrom(this), target, stream);
      break;
    }
    case kRecvfromNocancel: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          27, _Internal::recvfrom_nocancel(this), target, stream);
      break;
    }
    case kRecvmsg: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          28, _Internal::recvmsg(this), target, stream);
      break;
    }
    case kSendto: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          34, _Internal::sendto(this), target, stream);
      break;
    }
    case kSocketpair: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          38, _Internal::socketpair(this), target, stream);
      break;
    }
    case kPipe: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          39, _Internal::pipe(this), target, stream);
      break;
    }
    case kShutdown: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          40, _Internal::shutdown(this), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Command)
  return target;
}

size_t Command::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Command)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (command_case()) {
    // .Packet ip_input = 1;
    case kIpInput: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.ip_input_);
      break;
    }
    // .Ioctl ioctl = 3;
    case kIoctl: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.ioctl_);
      break;
    }
    // .SetSocketOpt set_sock_opt = 4;
    case kSetSockOpt: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.set_sock_opt_);
      break;
    }
    // .IoctlReal ioctl_real = 5;
    case kIoctlReal: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.ioctl_real_);
      break;
    }
    // .ConnectX connectx = 6;
    case kConnectx: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.connectx_);
      break;
    }
    // .Connect connect = 7;
    case kConnect: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.connect_);
      break;
    }
    // .Listen listen = 8;
    case kListen: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.listen_);
      break;
    }
    // .DisconnectX disconnectx = 9;
    case kDisconnectx: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.disconnectx_);
      break;
    }
    // .GetSocketOpt get_sock_opt = 10;
    case kGetSockOpt: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.get_sock_opt_);
      break;
    }
    // .Bind bind = 11;
    case kBind: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.bind_);
      break;
    }
    // .Accept accept = 12;
    case kAccept: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.accept_);
      break;
    }
    // .Socket socket = 13;
    case kSocket: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.socket_);
      break;
    }
    // .Close close = 14;
    case kClose: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.close_);
      break;
    }
    // .ClearAll clear_all = 15;
    case kClearAll: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.clear_all_);
      break;
    }
    // .NecpMatchPolicy necp_match_policy = 16;
    case kNecpMatchPolicy: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.necp_match_policy_);
      break;
    }
    // .NecpOpen necp_open = 17;
    case kNecpOpen: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.necp_open_);
      break;
    }
    // .NecpClientAction necp_client_action = 18;
    case kNecpClientAction: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.necp_client_action_);
      break;
    }
    // .NecpSessionOpen necp_session_open = 19;
    case kNecpSessionOpen: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.necp_session_open_);
      break;
    }
    // .NecpSessionAction necp_session_action = 20;
    case kNecpSessionAction: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.necp_session_action_);
      break;
    }
    // .AcceptNocancel accept_nocancel = 21;
    case kAcceptNocancel: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.accept_nocancel_);
      break;
    }
    // .ConnectNocancel connect_nocancel = 22;
    case kConnectNocancel: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.connect_nocancel_);
      break;
    }
    // .Getpeername getpeername = 23;
    case kGetpeername: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.getpeername_);
      break;
    }
    // .Getsockname getsockname = 24;
    case kGetsockname: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.getsockname_);
      break;
    }
    // .Peeloff peeloff = 25;
    case kPeeloff: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.peeloff_);
      break;
    }
    // .Recvfrom recvfrom = 26;
    case kRecvfrom: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.recvfrom_);
      break;
    }
    // .RecvfromNocancel recvfrom_nocancel = 27;
    case kRecvfromNocancel: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.recvfrom_nocancel_);
      break;
    }
    // .Recvmsg recvmsg = 28;
    case kRecvmsg: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.recvmsg_);
      break;
    }
    // .Sendto sendto = 34;
    case kSendto: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.sendto_);
      break;
    }
    // .Socketpair socketpair = 38;
    case kSocketpair: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.socketpair_);
      break;
    }
    // .Pipe pipe = 39;
    case kPipe: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.pipe_);
      break;
    }
    // .Shutdown shutdown = 40;
    case kShutdown: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.shutdown_);
      break;
    }
    case COMMAND_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Command::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Command::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Command::GetClassData() const { return &_class_data_; }

void Command::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Command *>(to)->MergeFrom(
      static_cast<const Command &>(from));
}


void Command::MergeFrom(const Command& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Command)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.command_case()) {
    case kIpInput: {
      _internal_mutable_ip_input()->::Packet::MergeFrom(from._internal_ip_input());
      break;
    }
    case kIoctl: {
      _internal_mutable_ioctl()->::Ioctl::MergeFrom(from._internal_ioctl());
      break;
    }
    case kSetSockOpt: {
      _internal_mutable_set_sock_opt()->::SetSocketOpt::MergeFrom(from._internal_set_sock_opt());
      break;
    }
    case kIoctlReal: {
      _internal_mutable_ioctl_real()->::IoctlReal::MergeFrom(from._internal_ioctl_real());
      break;
    }
    case kConnectx: {
      _internal_mutable_connectx()->::ConnectX::MergeFrom(from._internal_connectx());
      break;
    }
    case kConnect: {
      _internal_mutable_connect()->::Connect::MergeFrom(from._internal_connect());
      break;
    }
    case kListen: {
      _internal_mutable_listen()->::Listen::MergeFrom(from._internal_listen());
      break;
    }
    case kDisconnectx: {
      _internal_mutable_disconnectx()->::DisconnectX::MergeFrom(from._internal_disconnectx());
      break;
    }
    case kGetSockOpt: {
      _internal_mutable_get_sock_opt()->::GetSocketOpt::MergeFrom(from._internal_get_sock_opt());
      break;
    }
    case kBind: {
      _internal_mutable_bind()->::Bind::MergeFrom(from._internal_bind());
      break;
    }
    case kAccept: {
      _internal_mutable_accept()->::Accept::MergeFrom(from._internal_accept());
      break;
    }
    case kSocket: {
      _internal_mutable_socket()->::Socket::MergeFrom(from._internal_socket());
      break;
    }
    case kClose: {
      _internal_mutable_close()->::Close::MergeFrom(from._internal_close());
      break;
    }
    case kClearAll: {
      _internal_mutable_clear_all()->::ClearAll::MergeFrom(from._internal_clear_all());
      break;
    }
    case kNecpMatchPolicy: {
      _internal_mutable_necp_match_policy()->::NecpMatchPolicy::MergeFrom(from._internal_necp_match_policy());
      break;
    }
    case kNecpOpen: {
      _internal_mutable_necp_open()->::NecpOpen::MergeFrom(from._internal_necp_open());
      break;
    }
    case kNecpClientAction: {
      _internal_mutable_necp_client_action()->::NecpClientAction::MergeFrom(from._internal_necp_client_action());
      break;
    }
    case kNecpSessionOpen: {
      _internal_mutable_necp_session_open()->::NecpSessionOpen::MergeFrom(from._internal_necp_session_open());
      break;
    }
    case kNecpSessionAction: {
      _internal_mutable_necp_session_action()->::NecpSessionAction::MergeFrom(from._internal_necp_session_action());
      break;
    }
    case kAcceptNocancel: {
      _internal_mutable_accept_nocancel()->::AcceptNocancel::MergeFrom(from._internal_accept_nocancel());
      break;
    }
    case kConnectNocancel: {
      _internal_mutable_connect_nocancel()->::ConnectNocancel::MergeFrom(from._internal_connect_nocancel());
      break;
    }
    case kGetpeername: {
      _internal_mutable_getpeername()->::Getpeername::MergeFrom(from._internal_getpeername());
      break;
    }
    case kGetsockname: {
      _internal_mutable_getsockname()->::Getsockname::MergeFrom(from._internal_getsockname());
      break;
    }
    case kPeeloff: {
      _internal_mutable_peeloff()->::Peeloff::MergeFrom(from._internal_peeloff());
      break;
    }
    case kRecvfrom: {
      _internal_mutable_recvfrom()->::Recvfrom::MergeFrom(from._internal_recvfrom());
      break;
    }
    case kRecvfromNocancel: {
      _internal_mutable_recvfrom_nocancel()->::RecvfromNocancel::MergeFrom(from._internal_recvfrom_nocancel());
      break;
    }
    case kRecvmsg: {
      _internal_mutable_recvmsg()->::Recvmsg::MergeFrom(from._internal_recvmsg());
      break;
    }
    case kSendto: {
      _internal_mutable_sendto()->::Sendto::MergeFrom(from._internal_sendto());
      break;
    }
    case kSocketpair: {
      _internal_mutable_socketpair()->::Socketpair::MergeFrom(from._internal_socketpair());
      break;
    }
    case kPipe: {
      _internal_mutable_pipe()->::Pipe::MergeFrom(from._internal_pipe());
      break;
    }
    case kShutdown: {
      _internal_mutable_shutdown()->::Shutdown::MergeFrom(from._internal_shutdown());
      break;
    }
    case COMMAND_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Command::CopyFrom(const Command& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Command)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Command::IsInitialized() const {
  switch (command_case()) {
    case kIpInput: {
      if (has_ip_input()) {
        if (!this->ip_input().IsInitialized()) return false;
      }
      break;
    }
    case kIoctl: {
      if (has_ioctl()) {
        if (!this->ioctl().IsInitialized()) return false;
      }
      break;
    }
    case kSetSockOpt: {
      break;
    }
    case kIoctlReal: {
      if (has_ioctl_real()) {
        if (!this->ioctl_real().IsInitialized()) return false;
      }
      break;
    }
    case kConnectx: {
      if (has_connectx()) {
        if (!this->connectx().IsInitialized()) return false;
      }
      break;
    }
    case kConnect: {
      if (has_connect()) {
        if (!this->connect().IsInitialized()) return false;
      }
      break;
    }
    case kListen: {
      if (has_listen()) {
        if (!this->listen().IsInitialized()) return false;
      }
      break;
    }
    case kDisconnectx: {
      if (has_disconnectx()) {
        if (!this->disconnectx().IsInitialized()) return false;
      }
      break;
    }
    case kGetSockOpt: {
      break;
    }
    case kBind: {
      if (has_bind()) {
        if (!this->bind().IsInitialized()) return false;
      }
      break;
    }
    case kAccept: {
      if (has_accept()) {
        if (!this->accept().IsInitialized()) return false;
      }
      break;
    }
    case kSocket: {
      if (has_socket()) {
        if (!this->socket().IsInitialized()) return false;
      }
      break;
    }
    case kClose: {
      if (has_close()) {
        if (!this->close().IsInitialized()) return false;
      }
      break;
    }
    case kClearAll: {
      break;
    }
    case kNecpMatchPolicy: {
      break;
    }
    case kNecpOpen: {
      break;
    }
    case kNecpClientAction: {
      break;
    }
    case kNecpSessionOpen: {
      break;
    }
    case kNecpSessionAction: {
      break;
    }
    case kAcceptNocancel: {
      if (has_accept_nocancel()) {
        if (!this->accept_nocancel().IsInitialized()) return false;
      }
      break;
    }
    case kConnectNocancel: {
      if (has_connect_nocancel()) {
        if (!this->connect_nocancel().IsInitialized()) return false;
      }
      break;
    }
    case kGetpeername: {
      if (has_getpeername()) {
        if (!this->getpeername().IsInitialized()) return false;
      }
      break;
    }
    case kGetsockname: {
      if (has_getsockname()) {
        if (!this->getsockname().IsInitialized()) return false;
      }
      break;
    }
    case kPeeloff: {
      break;
    }
    case kRecvfrom: {
      if (has_recvfrom()) {
        if (!this->recvfrom().IsInitialized()) return false;
      }
      break;
    }
    case kRecvfromNocancel: {
      if (has_recvfrom_nocancel()) {
        if (!this->recvfrom_nocancel().IsInitialized()) return false;
      }
      break;
    }
    case kRecvmsg: {
      break;
    }
    case kSendto: {
      if (has_sendto()) {
        if (!this->sendto().IsInitialized()) return false;
      }
      break;
    }
    case kSocketpair: {
      break;
    }
    case kPipe: {
      break;
    }
    case kShutdown: {
      break;
    }
    case COMMAND_NOT_SET: {
      break;
    }
  }
  return true;
}

void Command::InternalSwap(Command* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(command_, other->command_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata Command::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[10]);
}

// ===================================================================

class AcceptNocancel::_Internal {
 public:
  using HasBits = decltype(std::declval<AcceptNocancel>()._has_bits_);
  static void set_has_s(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::SockAddr& name(const AcceptNocancel* msg);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::SockAddr&
AcceptNocancel::_Internal::name(const AcceptNocancel* msg) {
  return *msg->name_;
}
AcceptNocancel::AcceptNocancel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:AcceptNocancel)
}
AcceptNocancel::AcceptNocancel(const AcceptNocancel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_name()) {
    name_ = new ::SockAddr(*from.name_);
  } else {
    name_ = nullptr;
  }
  s_ = from.s_;
  // @@protoc_insertion_point(copy_constructor:AcceptNocancel)
}

void AcceptNocancel::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&name_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&s_) -
    reinterpret_cast<char*>(&name_)) + sizeof(s_));
}

AcceptNocancel::~AcceptNocancel() {
  // @@protoc_insertion_point(destructor:AcceptNocancel)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void AcceptNocancel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete name_;
}

void AcceptNocancel::ArenaDtor(void* object) {
  AcceptNocancel* _this = reinterpret_cast< AcceptNocancel* >(object);
  (void)_this;
}
void AcceptNocancel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void AcceptNocancel::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void AcceptNocancel::Clear() {
// @@protoc_insertion_point(message_clear_start:AcceptNocancel)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(name_ != nullptr);
    name_->Clear();
  }
  s_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* AcceptNocancel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor s = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_s(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .SockAddr name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_name(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* AcceptNocancel::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:AcceptNocancel)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor s = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_s(), target);
  }

  // optional .SockAddr name = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::name(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:AcceptNocancel)
  return target;
}

size_t AcceptNocancel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:AcceptNocancel)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .SockAddr name = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *name_);
    }

    // optional .FileDescriptor s = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_s());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AcceptNocancel::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    AcceptNocancel::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AcceptNocancel::GetClassData() const { return &_class_data_; }

void AcceptNocancel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<AcceptNocancel *>(to)->MergeFrom(
      static_cast<const AcceptNocancel &>(from));
}


void AcceptNocancel::MergeFrom(const AcceptNocancel& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:AcceptNocancel)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_name()->::SockAddr::MergeFrom(from._internal_name());
    }
    if (cached_has_bits & 0x00000002u) {
      s_ = from.s_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void AcceptNocancel::CopyFrom(const AcceptNocancel& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:AcceptNocancel)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AcceptNocancel::IsInitialized() const {
  if (_internal_has_name()) {
    if (!name_->IsInitialized()) return false;
  }
  return true;
}

void AcceptNocancel::InternalSwap(AcceptNocancel* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(AcceptNocancel, s_)
      + sizeof(AcceptNocancel::s_)
      - PROTOBUF_FIELD_OFFSET(AcceptNocancel, name_)>(
          reinterpret_cast<char*>(&name_),
          reinterpret_cast<char*>(&other->name_));
}

::PROTOBUF_NAMESPACE_ID::Metadata AcceptNocancel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[11]);
}

// ===================================================================

class ConnectNocancel::_Internal {
 public:
  using HasBits = decltype(std::declval<ConnectNocancel>()._has_bits_);
  static void set_has_s(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::SockAddr& name(const ConnectNocancel* msg);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::SockAddr&
ConnectNocancel::_Internal::name(const ConnectNocancel* msg) {
  return *msg->name_;
}
ConnectNocancel::ConnectNocancel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:ConnectNocancel)
}
ConnectNocancel::ConnectNocancel(const ConnectNocancel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_name()) {
    name_ = new ::SockAddr(*from.name_);
  } else {
    name_ = nullptr;
  }
  s_ = from.s_;
  // @@protoc_insertion_point(copy_constructor:ConnectNocancel)
}

void ConnectNocancel::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&name_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&s_) -
    reinterpret_cast<char*>(&name_)) + sizeof(s_));
}

ConnectNocancel::~ConnectNocancel() {
  // @@protoc_insertion_point(destructor:ConnectNocancel)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void ConnectNocancel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete name_;
}

void ConnectNocancel::ArenaDtor(void* object) {
  ConnectNocancel* _this = reinterpret_cast< ConnectNocancel* >(object);
  (void)_this;
}
void ConnectNocancel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ConnectNocancel::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ConnectNocancel::Clear() {
// @@protoc_insertion_point(message_clear_start:ConnectNocancel)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(name_ != nullptr);
    name_->Clear();
  }
  s_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ConnectNocancel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor s = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_s(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .SockAddr name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_name(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ConnectNocancel::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:ConnectNocancel)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor s = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_s(), target);
  }

  // optional .SockAddr name = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::name(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:ConnectNocancel)
  return target;
}

size_t ConnectNocancel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:ConnectNocancel)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .SockAddr name = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *name_);
    }

    // optional .FileDescriptor s = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_s());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ConnectNocancel::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    ConnectNocancel::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ConnectNocancel::GetClassData() const { return &_class_data_; }

void ConnectNocancel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<ConnectNocancel *>(to)->MergeFrom(
      static_cast<const ConnectNocancel &>(from));
}


void ConnectNocancel::MergeFrom(const ConnectNocancel& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:ConnectNocancel)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_name()->::SockAddr::MergeFrom(from._internal_name());
    }
    if (cached_has_bits & 0x00000002u) {
      s_ = from.s_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void ConnectNocancel::CopyFrom(const ConnectNocancel& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ConnectNocancel)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ConnectNocancel::IsInitialized() const {
  if (_internal_has_name()) {
    if (!name_->IsInitialized()) return false;
  }
  return true;
}

void ConnectNocancel::InternalSwap(ConnectNocancel* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ConnectNocancel, s_)
      + sizeof(ConnectNocancel::s_)
      - PROTOBUF_FIELD_OFFSET(ConnectNocancel, name_)>(
          reinterpret_cast<char*>(&name_),
          reinterpret_cast<char*>(&other->name_));
}

::PROTOBUF_NAMESPACE_ID::Metadata ConnectNocancel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[12]);
}

// ===================================================================

class Getpeername::_Internal {
 public:
  using HasBits = decltype(std::declval<Getpeername>()._has_bits_);
  static void set_has_fdes(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::SockAddr& asa(const Getpeername* msg);
  static void set_has_asa(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::SockAddr&
Getpeername::_Internal::asa(const Getpeername* msg) {
  return *msg->asa_;
}
Getpeername::Getpeername(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Getpeername)
}
Getpeername::Getpeername(const Getpeername& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_asa()) {
    asa_ = new ::SockAddr(*from.asa_);
  } else {
    asa_ = nullptr;
  }
  fdes_ = from.fdes_;
  // @@protoc_insertion_point(copy_constructor:Getpeername)
}

void Getpeername::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&asa_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&fdes_) -
    reinterpret_cast<char*>(&asa_)) + sizeof(fdes_));
}

Getpeername::~Getpeername() {
  // @@protoc_insertion_point(destructor:Getpeername)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Getpeername::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete asa_;
}

void Getpeername::ArenaDtor(void* object) {
  Getpeername* _this = reinterpret_cast< Getpeername* >(object);
  (void)_this;
}
void Getpeername::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Getpeername::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Getpeername::Clear() {
// @@protoc_insertion_point(message_clear_start:Getpeername)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(asa_ != nullptr);
    asa_->Clear();
  }
  fdes_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Getpeername::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor fdes = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_fdes(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .SockAddr asa = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_asa(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Getpeername::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Getpeername)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor fdes = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_fdes(), target);
  }

  // optional .SockAddr asa = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::asa(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Getpeername)
  return target;
}

size_t Getpeername::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Getpeername)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .SockAddr asa = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *asa_);
    }

    // optional .FileDescriptor fdes = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fdes());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Getpeername::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Getpeername::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Getpeername::GetClassData() const { return &_class_data_; }

void Getpeername::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Getpeername *>(to)->MergeFrom(
      static_cast<const Getpeername &>(from));
}


void Getpeername::MergeFrom(const Getpeername& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Getpeername)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_asa()->::SockAddr::MergeFrom(from._internal_asa());
    }
    if (cached_has_bits & 0x00000002u) {
      fdes_ = from.fdes_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Getpeername::CopyFrom(const Getpeername& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Getpeername)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Getpeername::IsInitialized() const {
  if (_internal_has_asa()) {
    if (!asa_->IsInitialized()) return false;
  }
  return true;
}

void Getpeername::InternalSwap(Getpeername* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Getpeername, fdes_)
      + sizeof(Getpeername::fdes_)
      - PROTOBUF_FIELD_OFFSET(Getpeername, asa_)>(
          reinterpret_cast<char*>(&asa_),
          reinterpret_cast<char*>(&other->asa_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Getpeername::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[13]);
}

// ===================================================================

class Getsockname::_Internal {
 public:
  using HasBits = decltype(std::declval<Getsockname>()._has_bits_);
  static void set_has_fdes(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::SockAddr& asa(const Getsockname* msg);
  static void set_has_asa(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::SockAddr&
Getsockname::_Internal::asa(const Getsockname* msg) {
  return *msg->asa_;
}
Getsockname::Getsockname(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Getsockname)
}
Getsockname::Getsockname(const Getsockname& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_asa()) {
    asa_ = new ::SockAddr(*from.asa_);
  } else {
    asa_ = nullptr;
  }
  fdes_ = from.fdes_;
  // @@protoc_insertion_point(copy_constructor:Getsockname)
}

void Getsockname::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&asa_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&fdes_) -
    reinterpret_cast<char*>(&asa_)) + sizeof(fdes_));
}

Getsockname::~Getsockname() {
  // @@protoc_insertion_point(destructor:Getsockname)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Getsockname::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete asa_;
}

void Getsockname::ArenaDtor(void* object) {
  Getsockname* _this = reinterpret_cast< Getsockname* >(object);
  (void)_this;
}
void Getsockname::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Getsockname::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Getsockname::Clear() {
// @@protoc_insertion_point(message_clear_start:Getsockname)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(asa_ != nullptr);
    asa_->Clear();
  }
  fdes_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Getsockname::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor fdes = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_fdes(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .SockAddr asa = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_asa(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Getsockname::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Getsockname)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor fdes = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_fdes(), target);
  }

  // optional .SockAddr asa = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::asa(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Getsockname)
  return target;
}

size_t Getsockname::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Getsockname)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .SockAddr asa = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *asa_);
    }

    // optional .FileDescriptor fdes = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fdes());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Getsockname::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Getsockname::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Getsockname::GetClassData() const { return &_class_data_; }

void Getsockname::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Getsockname *>(to)->MergeFrom(
      static_cast<const Getsockname &>(from));
}


void Getsockname::MergeFrom(const Getsockname& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Getsockname)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_asa()->::SockAddr::MergeFrom(from._internal_asa());
    }
    if (cached_has_bits & 0x00000002u) {
      fdes_ = from.fdes_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Getsockname::CopyFrom(const Getsockname& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Getsockname)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Getsockname::IsInitialized() const {
  if (_internal_has_asa()) {
    if (!asa_->IsInitialized()) return false;
  }
  return true;
}

void Getsockname::InternalSwap(Getsockname* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Getsockname, fdes_)
      + sizeof(Getsockname::fdes_)
      - PROTOBUF_FIELD_OFFSET(Getsockname, asa_)>(
          reinterpret_cast<char*>(&asa_),
          reinterpret_cast<char*>(&other->asa_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Getsockname::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[14]);
}

// ===================================================================

class Peeloff::_Internal {
 public:
  using HasBits = decltype(std::declval<Peeloff>()._has_bits_);
  static void set_has_s(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_aid(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

Peeloff::Peeloff(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Peeloff)
}
Peeloff::Peeloff(const Peeloff& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&s_, &from.s_,
    static_cast<size_t>(reinterpret_cast<char*>(&aid_) -
    reinterpret_cast<char*>(&s_)) + sizeof(aid_));
  // @@protoc_insertion_point(copy_constructor:Peeloff)
}

void Peeloff::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&s_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&aid_) -
    reinterpret_cast<char*>(&s_)) + sizeof(aid_));
}

Peeloff::~Peeloff() {
  // @@protoc_insertion_point(destructor:Peeloff)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Peeloff::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Peeloff::ArenaDtor(void* object) {
  Peeloff* _this = reinterpret_cast< Peeloff* >(object);
  (void)_this;
}
void Peeloff::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Peeloff::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Peeloff::Clear() {
// @@protoc_insertion_point(message_clear_start:Peeloff)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&s_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&aid_) -
        reinterpret_cast<char*>(&s_)) + sizeof(aid_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Peeloff::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor s = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_s(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .SaeAssocID aid = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SaeAssocID_IsValid(val))) {
            _internal_set_aid(static_cast<::SaeAssocID>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Peeloff::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Peeloff)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor s = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_s(), target);
  }

  // optional .SaeAssocID aid = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_aid(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Peeloff)
  return target;
}

size_t Peeloff::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Peeloff)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .FileDescriptor s = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_s());
    }

    // optional .SaeAssocID aid = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_aid());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Peeloff::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Peeloff::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Peeloff::GetClassData() const { return &_class_data_; }

void Peeloff::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Peeloff *>(to)->MergeFrom(
      static_cast<const Peeloff &>(from));
}


void Peeloff::MergeFrom(const Peeloff& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Peeloff)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      s_ = from.s_;
    }
    if (cached_has_bits & 0x00000002u) {
      aid_ = from.aid_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Peeloff::CopyFrom(const Peeloff& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Peeloff)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Peeloff::IsInitialized() const {
  return true;
}

void Peeloff::InternalSwap(Peeloff* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Peeloff, aid_)
      + sizeof(Peeloff::aid_)
      - PROTOBUF_FIELD_OFFSET(Peeloff, s_)>(
          reinterpret_cast<char*>(&s_),
          reinterpret_cast<char*>(&other->s_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Peeloff::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[15]);
}

// ===================================================================

class Pipe::_Internal {
 public:
};

Pipe::Pipe(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:Pipe)
}
Pipe::Pipe(const Pipe& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:Pipe)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Pipe::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Pipe::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata Pipe::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[16]);
}

// ===================================================================

class Shutdown::_Internal {
 public:
  using HasBits = decltype(std::declval<Shutdown>()._has_bits_);
  static void set_has_s(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_how(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

Shutdown::Shutdown(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Shutdown)
}
Shutdown::Shutdown(const Shutdown& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&s_, &from.s_,
    static_cast<size_t>(reinterpret_cast<char*>(&how_) -
    reinterpret_cast<char*>(&s_)) + sizeof(how_));
  // @@protoc_insertion_point(copy_constructor:Shutdown)
}

void Shutdown::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&s_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&how_) -
    reinterpret_cast<char*>(&s_)) + sizeof(how_));
}

Shutdown::~Shutdown() {
  // @@protoc_insertion_point(destructor:Shutdown)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Shutdown::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Shutdown::ArenaDtor(void* object) {
  Shutdown* _this = reinterpret_cast< Shutdown* >(object);
  (void)_this;
}
void Shutdown::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Shutdown::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Shutdown::Clear() {
// @@protoc_insertion_point(message_clear_start:Shutdown)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&s_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&how_) -
        reinterpret_cast<char*>(&s_)) + sizeof(how_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Shutdown::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor s = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_s(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .ShutdownHow how = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::ShutdownHow_IsValid(val))) {
            _internal_set_how(static_cast<::ShutdownHow>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Shutdown::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Shutdown)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor s = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_s(), target);
  }

  // optional .ShutdownHow how = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_how(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Shutdown)
  return target;
}

size_t Shutdown::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Shutdown)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .FileDescriptor s = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_s());
    }

    // optional .ShutdownHow how = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_how());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Shutdown::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Shutdown::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Shutdown::GetClassData() const { return &_class_data_; }

void Shutdown::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Shutdown *>(to)->MergeFrom(
      static_cast<const Shutdown &>(from));
}


void Shutdown::MergeFrom(const Shutdown& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Shutdown)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      s_ = from.s_;
    }
    if (cached_has_bits & 0x00000002u) {
      how_ = from.how_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Shutdown::CopyFrom(const Shutdown& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Shutdown)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Shutdown::IsInitialized() const {
  return true;
}

void Shutdown::InternalSwap(Shutdown* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Shutdown, how_)
      + sizeof(Shutdown::how_)
      - PROTOBUF_FIELD_OFFSET(Shutdown, s_)>(
          reinterpret_cast<char*>(&s_),
          reinterpret_cast<char*>(&other->s_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Shutdown::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[17]);
}

// ===================================================================

class Recvfrom::_Internal {
 public:
  using HasBits = decltype(std::declval<Recvfrom>()._has_bits_);
  static void set_has_s(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_buf(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_flags(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::SockAddr& from(const Recvfrom* msg);
  static void set_has_from(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SockAddr&
Recvfrom::_Internal::from(const Recvfrom* msg) {
  return *msg->from_;
}
Recvfrom::Recvfrom(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Recvfrom)
}
Recvfrom::Recvfrom(const Recvfrom& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  buf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_buf()) {
    buf_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_buf(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_from()) {
    from_ = new ::SockAddr(*from.from_);
  } else {
    from_ = nullptr;
  }
  ::memcpy(&s_, &from.s_,
    static_cast<size_t>(reinterpret_cast<char*>(&flags_) -
    reinterpret_cast<char*>(&s_)) + sizeof(flags_));
  // @@protoc_insertion_point(copy_constructor:Recvfrom)
}

void Recvfrom::SharedCtor() {
buf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&from_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&flags_) -
    reinterpret_cast<char*>(&from_)) + sizeof(flags_));
}

Recvfrom::~Recvfrom() {
  // @@protoc_insertion_point(destructor:Recvfrom)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Recvfrom::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  buf_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete from_;
}

void Recvfrom::ArenaDtor(void* object) {
  Recvfrom* _this = reinterpret_cast< Recvfrom* >(object);
  (void)_this;
}
void Recvfrom::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Recvfrom::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Recvfrom::Clear() {
// @@protoc_insertion_point(message_clear_start:Recvfrom)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      buf_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(from_ != nullptr);
      from_->Clear();
    }
  }
  if (cached_has_bits & 0x0000000cu) {
    ::memset(&s_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&flags_) -
        reinterpret_cast<char*>(&s_)) + sizeof(flags_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Recvfrom::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor s = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_s(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional bytes buf = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_buf();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 flags = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_flags(&has_bits);
          flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .SockAddr from = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_from(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Recvfrom::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Recvfrom)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor s = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_s(), target);
  }

  // optional bytes buf = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_buf(), target);
  }

  // optional int32 flags = 3;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_flags(), target);
  }

  // optional .SockAddr from = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::from(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Recvfrom)
  return target;
}

size_t Recvfrom::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Recvfrom)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional bytes buf = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_buf());
    }

    // optional .SockAddr from = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *from_);
    }

    // optional .FileDescriptor s = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_s());
    }

    // optional int32 flags = 3;
    if (cached_has_bits & 0x00000008u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_flags());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Recvfrom::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Recvfrom::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Recvfrom::GetClassData() const { return &_class_data_; }

void Recvfrom::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Recvfrom *>(to)->MergeFrom(
      static_cast<const Recvfrom &>(from));
}


void Recvfrom::MergeFrom(const Recvfrom& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Recvfrom)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_buf(from._internal_buf());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_from()->::SockAddr::MergeFrom(from._internal_from());
    }
    if (cached_has_bits & 0x00000004u) {
      s_ = from.s_;
    }
    if (cached_has_bits & 0x00000008u) {
      flags_ = from.flags_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Recvfrom::CopyFrom(const Recvfrom& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Recvfrom)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Recvfrom::IsInitialized() const {
  if (_internal_has_from()) {
    if (!from_->IsInitialized()) return false;
  }
  return true;
}

void Recvfrom::InternalSwap(Recvfrom* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &buf_, lhs_arena,
      &other->buf_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Recvfrom, flags_)
      + sizeof(Recvfrom::flags_)
      - PROTOBUF_FIELD_OFFSET(Recvfrom, from_)>(
          reinterpret_cast<char*>(&from_),
          reinterpret_cast<char*>(&other->from_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Recvfrom::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[18]);
}

// ===================================================================

class RecvfromNocancel::_Internal {
 public:
  using HasBits = decltype(std::declval<RecvfromNocancel>()._has_bits_);
  static void set_has_s(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_buf(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_flags(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::SockAddr& from(const RecvfromNocancel* msg);
  static void set_has_from(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SockAddr&
RecvfromNocancel::_Internal::from(const RecvfromNocancel* msg) {
  return *msg->from_;
}
RecvfromNocancel::RecvfromNocancel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:RecvfromNocancel)
}
RecvfromNocancel::RecvfromNocancel(const RecvfromNocancel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  buf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_buf()) {
    buf_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_buf(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_from()) {
    from_ = new ::SockAddr(*from.from_);
  } else {
    from_ = nullptr;
  }
  ::memcpy(&s_, &from.s_,
    static_cast<size_t>(reinterpret_cast<char*>(&flags_) -
    reinterpret_cast<char*>(&s_)) + sizeof(flags_));
  // @@protoc_insertion_point(copy_constructor:RecvfromNocancel)
}

void RecvfromNocancel::SharedCtor() {
buf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&from_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&flags_) -
    reinterpret_cast<char*>(&from_)) + sizeof(flags_));
}

RecvfromNocancel::~RecvfromNocancel() {
  // @@protoc_insertion_point(destructor:RecvfromNocancel)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void RecvfromNocancel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  buf_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete from_;
}

void RecvfromNocancel::ArenaDtor(void* object) {
  RecvfromNocancel* _this = reinterpret_cast< RecvfromNocancel* >(object);
  (void)_this;
}
void RecvfromNocancel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RecvfromNocancel::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void RecvfromNocancel::Clear() {
// @@protoc_insertion_point(message_clear_start:RecvfromNocancel)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      buf_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(from_ != nullptr);
      from_->Clear();
    }
  }
  if (cached_has_bits & 0x0000000cu) {
    ::memset(&s_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&flags_) -
        reinterpret_cast<char*>(&s_)) + sizeof(flags_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RecvfromNocancel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor s = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_s(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional bytes buf = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_buf();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 flags = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_flags(&has_bits);
          flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .SockAddr from = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_from(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RecvfromNocancel::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RecvfromNocancel)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor s = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_s(), target);
  }

  // optional bytes buf = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_buf(), target);
  }

  // optional int32 flags = 3;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_flags(), target);
  }

  // optional .SockAddr from = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::from(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RecvfromNocancel)
  return target;
}

size_t RecvfromNocancel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RecvfromNocancel)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional bytes buf = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_buf());
    }

    // optional .SockAddr from = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *from_);
    }

    // optional .FileDescriptor s = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_s());
    }

    // optional int32 flags = 3;
    if (cached_has_bits & 0x00000008u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_flags());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RecvfromNocancel::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    RecvfromNocancel::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RecvfromNocancel::GetClassData() const { return &_class_data_; }

void RecvfromNocancel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<RecvfromNocancel *>(to)->MergeFrom(
      static_cast<const RecvfromNocancel &>(from));
}


void RecvfromNocancel::MergeFrom(const RecvfromNocancel& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RecvfromNocancel)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_buf(from._internal_buf());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_from()->::SockAddr::MergeFrom(from._internal_from());
    }
    if (cached_has_bits & 0x00000004u) {
      s_ = from.s_;
    }
    if (cached_has_bits & 0x00000008u) {
      flags_ = from.flags_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void RecvfromNocancel::CopyFrom(const RecvfromNocancel& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RecvfromNocancel)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RecvfromNocancel::IsInitialized() const {
  if (_internal_has_from()) {
    if (!from_->IsInitialized()) return false;
  }
  return true;
}

void RecvfromNocancel::InternalSwap(RecvfromNocancel* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &buf_, lhs_arena,
      &other->buf_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RecvfromNocancel, flags_)
      + sizeof(RecvfromNocancel::flags_)
      - PROTOBUF_FIELD_OFFSET(RecvfromNocancel, from_)>(
          reinterpret_cast<char*>(&from_),
          reinterpret_cast<char*>(&other->from_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RecvfromNocancel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[19]);
}

// ===================================================================

class Recvmsg::_Internal {
 public:
  using HasBits = decltype(std::declval<Recvmsg>()._has_bits_);
  static void set_has_s(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_flags(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

Recvmsg::Recvmsg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Recvmsg)
}
Recvmsg::Recvmsg(const Recvmsg& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&s_, &from.s_,
    static_cast<size_t>(reinterpret_cast<char*>(&flags_) -
    reinterpret_cast<char*>(&s_)) + sizeof(flags_));
  // @@protoc_insertion_point(copy_constructor:Recvmsg)
}

void Recvmsg::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&s_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&flags_) -
    reinterpret_cast<char*>(&s_)) + sizeof(flags_));
}

Recvmsg::~Recvmsg() {
  // @@protoc_insertion_point(destructor:Recvmsg)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Recvmsg::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Recvmsg::ArenaDtor(void* object) {
  Recvmsg* _this = reinterpret_cast< Recvmsg* >(object);
  (void)_this;
}
void Recvmsg::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Recvmsg::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Recvmsg::Clear() {
// @@protoc_insertion_point(message_clear_start:Recvmsg)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&s_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&flags_) -
        reinterpret_cast<char*>(&s_)) + sizeof(flags_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Recvmsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor s = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_s(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional uint32 flags = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_flags(&has_bits);
          flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Recvmsg::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Recvmsg)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor s = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_s(), target);
  }

  // optional uint32 flags = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_flags(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Recvmsg)
  return target;
}

size_t Recvmsg::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Recvmsg)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .FileDescriptor s = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_s());
    }

    // optional uint32 flags = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Recvmsg::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Recvmsg::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Recvmsg::GetClassData() const { return &_class_data_; }

void Recvmsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Recvmsg *>(to)->MergeFrom(
      static_cast<const Recvmsg &>(from));
}


void Recvmsg::MergeFrom(const Recvmsg& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Recvmsg)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      s_ = from.s_;
    }
    if (cached_has_bits & 0x00000002u) {
      flags_ = from.flags_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Recvmsg::CopyFrom(const Recvmsg& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Recvmsg)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Recvmsg::IsInitialized() const {
  return true;
}

void Recvmsg::InternalSwap(Recvmsg* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Recvmsg, flags_)
      + sizeof(Recvmsg::flags_)
      - PROTOBUF_FIELD_OFFSET(Recvmsg, s_)>(
          reinterpret_cast<char*>(&s_),
          reinterpret_cast<char*>(&other->s_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Recvmsg::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[20]);
}

// ===================================================================

class Sendmsg::_Internal {
 public:
  using HasBits = decltype(std::declval<Sendmsg>()._has_bits_);
  static void set_has_s(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_msg(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_flags(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

Sendmsg::Sendmsg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Sendmsg)
}
Sendmsg::Sendmsg(const Sendmsg& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  msg_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_msg()) {
    msg_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_msg(), 
      GetArenaForAllocation());
  }
  ::memcpy(&s_, &from.s_,
    static_cast<size_t>(reinterpret_cast<char*>(&flags_) -
    reinterpret_cast<char*>(&s_)) + sizeof(flags_));
  // @@protoc_insertion_point(copy_constructor:Sendmsg)
}

void Sendmsg::SharedCtor() {
msg_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&s_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&flags_) -
    reinterpret_cast<char*>(&s_)) + sizeof(flags_));
}

Sendmsg::~Sendmsg() {
  // @@protoc_insertion_point(destructor:Sendmsg)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Sendmsg::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  msg_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Sendmsg::ArenaDtor(void* object) {
  Sendmsg* _this = reinterpret_cast< Sendmsg* >(object);
  (void)_this;
}
void Sendmsg::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Sendmsg::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Sendmsg::Clear() {
// @@protoc_insertion_point(message_clear_start:Sendmsg)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    msg_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&s_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&flags_) -
        reinterpret_cast<char*>(&s_)) + sizeof(flags_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Sendmsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor s = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_s(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional bytes msg = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_msg();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 flags = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_flags(&has_bits);
          flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Sendmsg::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Sendmsg)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor s = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_s(), target);
  }

  // optional bytes msg = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_msg(), target);
  }

  // optional uint32 flags = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_flags(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Sendmsg)
  return target;
}

size_t Sendmsg::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Sendmsg)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional bytes msg = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_msg());
    }

    // optional .FileDescriptor s = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_s());
    }

    // optional uint32 flags = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Sendmsg::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Sendmsg::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Sendmsg::GetClassData() const { return &_class_data_; }

void Sendmsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Sendmsg *>(to)->MergeFrom(
      static_cast<const Sendmsg &>(from));
}


void Sendmsg::MergeFrom(const Sendmsg& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Sendmsg)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_msg(from._internal_msg());
    }
    if (cached_has_bits & 0x00000002u) {
      s_ = from.s_;
    }
    if (cached_has_bits & 0x00000004u) {
      flags_ = from.flags_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Sendmsg::CopyFrom(const Sendmsg& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Sendmsg)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Sendmsg::IsInitialized() const {
  return true;
}

void Sendmsg::InternalSwap(Sendmsg* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &msg_, lhs_arena,
      &other->msg_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Sendmsg, flags_)
      + sizeof(Sendmsg::flags_)
      - PROTOBUF_FIELD_OFFSET(Sendmsg, s_)>(
          reinterpret_cast<char*>(&s_),
          reinterpret_cast<char*>(&other->s_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Sendmsg::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[21]);
}

// ===================================================================

class Sendto::_Internal {
 public:
  using HasBits = decltype(std::declval<Sendto>()._has_bits_);
  static void set_has_s(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_buf(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_flags(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::SockAddr& to(const Sendto* msg);
  static void set_has_to(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SockAddr&
Sendto::_Internal::to(const Sendto* msg) {
  return *msg->to_;
}
Sendto::Sendto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Sendto)
}
Sendto::Sendto(const Sendto& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  buf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_buf()) {
    buf_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_buf(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_to()) {
    to_ = new ::SockAddr(*from.to_);
  } else {
    to_ = nullptr;
  }
  ::memcpy(&s_, &from.s_,
    static_cast<size_t>(reinterpret_cast<char*>(&flags_) -
    reinterpret_cast<char*>(&s_)) + sizeof(flags_));
  // @@protoc_insertion_point(copy_constructor:Sendto)
}

void Sendto::SharedCtor() {
buf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&to_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&flags_) -
    reinterpret_cast<char*>(&to_)) + sizeof(flags_));
}

Sendto::~Sendto() {
  // @@protoc_insertion_point(destructor:Sendto)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Sendto::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  buf_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete to_;
}

void Sendto::ArenaDtor(void* object) {
  Sendto* _this = reinterpret_cast< Sendto* >(object);
  (void)_this;
}
void Sendto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Sendto::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Sendto::Clear() {
// @@protoc_insertion_point(message_clear_start:Sendto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      buf_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(to_ != nullptr);
      to_->Clear();
    }
  }
  if (cached_has_bits & 0x0000000cu) {
    ::memset(&s_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&flags_) -
        reinterpret_cast<char*>(&s_)) + sizeof(flags_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Sendto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor s = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_s(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional bytes buf = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_buf();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 flags = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_flags(&has_bits);
          flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .SockAddr to = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_to(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Sendto::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Sendto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor s = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_s(), target);
  }

  // optional bytes buf = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_buf(), target);
  }

  // optional int32 flags = 3;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_flags(), target);
  }

  // optional .SockAddr to = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::to(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Sendto)
  return target;
}

size_t Sendto::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Sendto)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional bytes buf = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_buf());
    }

    // optional .SockAddr to = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *to_);
    }

    // optional .FileDescriptor s = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_s());
    }

    // optional int32 flags = 3;
    if (cached_has_bits & 0x00000008u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_flags());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Sendto::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Sendto::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Sendto::GetClassData() const { return &_class_data_; }

void Sendto::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Sendto *>(to)->MergeFrom(
      static_cast<const Sendto &>(from));
}


void Sendto::MergeFrom(const Sendto& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Sendto)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_buf(from._internal_buf());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_to()->::SockAddr::MergeFrom(from._internal_to());
    }
    if (cached_has_bits & 0x00000004u) {
      s_ = from.s_;
    }
    if (cached_has_bits & 0x00000008u) {
      flags_ = from.flags_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Sendto::CopyFrom(const Sendto& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Sendto)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Sendto::IsInitialized() const {
  if (_internal_has_to()) {
    if (!to_->IsInitialized()) return false;
  }
  return true;
}

void Sendto::InternalSwap(Sendto* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &buf_, lhs_arena,
      &other->buf_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Sendto, flags_)
      + sizeof(Sendto::flags_)
      - PROTOBUF_FIELD_OFFSET(Sendto, to_)>(
          reinterpret_cast<char*>(&to_),
          reinterpret_cast<char*>(&other->to_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Sendto::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[22]);
}

// ===================================================================

class Socketpair::_Internal {
 public:
  using HasBits = decltype(std::declval<Socketpair>()._has_bits_);
  static void set_has_domain(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_protocol(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

Socketpair::Socketpair(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Socketpair)
}
Socketpair::Socketpair(const Socketpair& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&domain_, &from.domain_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&domain_)) + sizeof(type_));
  // @@protoc_insertion_point(copy_constructor:Socketpair)
}

void Socketpair::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&domain_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&protocol_) -
    reinterpret_cast<char*>(&domain_)) + sizeof(protocol_));
type_ = 1;
}

Socketpair::~Socketpair() {
  // @@protoc_insertion_point(destructor:Socketpair)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Socketpair::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Socketpair::ArenaDtor(void* object) {
  Socketpair* _this = reinterpret_cast< Socketpair* >(object);
  (void)_this;
}
void Socketpair::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Socketpair::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Socketpair::Clear() {
// @@protoc_insertion_point(message_clear_start:Socketpair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&domain_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&protocol_) -
        reinterpret_cast<char*>(&domain_)) + sizeof(protocol_));
    type_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Socketpair::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .Domain domain = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Domain_IsValid(val))) {
            _internal_set_domain(static_cast<::Domain>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .SoType type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SoType_IsValid(val))) {
            _internal_set_type(static_cast<::SoType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .Protocol protocol = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Protocol_IsValid(val))) {
            _internal_set_protocol(static_cast<::Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Socketpair::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Socketpair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .Domain domain = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_domain(), target);
  }

  // optional .SoType type = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_type(), target);
  }

  // optional .Protocol protocol = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_protocol(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Socketpair)
  return target;
}

size_t Socketpair::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Socketpair)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional .Domain domain = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_domain());
    }

    // optional .Protocol protocol = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_protocol());
    }

    // optional .SoType type = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Socketpair::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Socketpair::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Socketpair::GetClassData() const { return &_class_data_; }

void Socketpair::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Socketpair *>(to)->MergeFrom(
      static_cast<const Socketpair &>(from));
}


void Socketpair::MergeFrom(const Socketpair& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Socketpair)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      domain_ = from.domain_;
    }
    if (cached_has_bits & 0x00000002u) {
      protocol_ = from.protocol_;
    }
    if (cached_has_bits & 0x00000004u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Socketpair::CopyFrom(const Socketpair& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Socketpair)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Socketpair::IsInitialized() const {
  return true;
}

void Socketpair::InternalSwap(Socketpair* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Socketpair, protocol_)
      + sizeof(Socketpair::protocol_)
      - PROTOBUF_FIELD_OFFSET(Socketpair, domain_)>(
          reinterpret_cast<char*>(&domain_),
          reinterpret_cast<char*>(&other->domain_));
  swap(type_, other->type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Socketpair::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[23]);
}

// ===================================================================

class NecpSessionOpen::_Internal {
 public:
};

NecpSessionOpen::NecpSessionOpen(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:NecpSessionOpen)
}
NecpSessionOpen::NecpSessionOpen(const NecpSessionOpen& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:NecpSessionOpen)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NecpSessionOpen::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NecpSessionOpen::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata NecpSessionOpen::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[24]);
}

// ===================================================================

class NecpSessionAction::_Internal {
 public:
  using HasBits = decltype(std::declval<NecpSessionAction>()._has_bits_);
  static void set_has_necp_fd(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_action(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_in_buffer(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_out_buffer_size(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

NecpSessionAction::NecpSessionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:NecpSessionAction)
}
NecpSessionAction::NecpSessionAction(const NecpSessionAction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  in_buffer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_in_buffer()) {
    in_buffer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_in_buffer(), 
      GetArenaForAllocation());
  }
  ::memcpy(&necp_fd_, &from.necp_fd_,
    static_cast<size_t>(reinterpret_cast<char*>(&action_) -
    reinterpret_cast<char*>(&necp_fd_)) + sizeof(action_));
  // @@protoc_insertion_point(copy_constructor:NecpSessionAction)
}

void NecpSessionAction::SharedCtor() {
in_buffer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&necp_fd_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&out_buffer_size_) -
    reinterpret_cast<char*>(&necp_fd_)) + sizeof(out_buffer_size_));
action_ = 1;
}

NecpSessionAction::~NecpSessionAction() {
  // @@protoc_insertion_point(destructor:NecpSessionAction)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NecpSessionAction::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  in_buffer_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void NecpSessionAction::ArenaDtor(void* object) {
  NecpSessionAction* _this = reinterpret_cast< NecpSessionAction* >(object);
  (void)_this;
}
void NecpSessionAction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NecpSessionAction::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NecpSessionAction::Clear() {
// @@protoc_insertion_point(message_clear_start:NecpSessionAction)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    in_buffer_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x0000000eu) {
    ::memset(&necp_fd_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&out_buffer_size_) -
        reinterpret_cast<char*>(&necp_fd_)) + sizeof(out_buffer_size_));
    action_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NecpSessionAction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor necp_fd = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_necp_fd(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .NecpSessionActionNumber action = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::NecpSessionActionNumber_IsValid(val))) {
            _internal_set_action(static_cast<::NecpSessionActionNumber>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional bytes in_buffer = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_in_buffer();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 out_buffer_size = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_out_buffer_size(&has_bits);
          out_buffer_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NecpSessionAction::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:NecpSessionAction)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor necp_fd = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_necp_fd(), target);
  }

  // optional .NecpSessionActionNumber action = 2;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_action(), target);
  }

  // optional bytes in_buffer = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        3, this->_internal_in_buffer(), target);
  }

  // optional uint32 out_buffer_size = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_out_buffer_size(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:NecpSessionAction)
  return target;
}

size_t NecpSessionAction::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:NecpSessionAction)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional bytes in_buffer = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_in_buffer());
    }

    // optional .FileDescriptor necp_fd = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_necp_fd());
    }

    // optional uint32 out_buffer_size = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_out_buffer_size());
    }

    // optional .NecpSessionActionNumber action = 2;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_action());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NecpSessionAction::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NecpSessionAction::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NecpSessionAction::GetClassData() const { return &_class_data_; }

void NecpSessionAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<NecpSessionAction *>(to)->MergeFrom(
      static_cast<const NecpSessionAction &>(from));
}


void NecpSessionAction::MergeFrom(const NecpSessionAction& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:NecpSessionAction)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_in_buffer(from._internal_in_buffer());
    }
    if (cached_has_bits & 0x00000002u) {
      necp_fd_ = from.necp_fd_;
    }
    if (cached_has_bits & 0x00000004u) {
      out_buffer_size_ = from.out_buffer_size_;
    }
    if (cached_has_bits & 0x00000008u) {
      action_ = from.action_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NecpSessionAction::CopyFrom(const NecpSessionAction& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:NecpSessionAction)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NecpSessionAction::IsInitialized() const {
  return true;
}

void NecpSessionAction::InternalSwap(NecpSessionAction* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &in_buffer_, lhs_arena,
      &other->in_buffer_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(NecpSessionAction, out_buffer_size_)
      + sizeof(NecpSessionAction::out_buffer_size_)
      - PROTOBUF_FIELD_OFFSET(NecpSessionAction, necp_fd_)>(
          reinterpret_cast<char*>(&necp_fd_),
          reinterpret_cast<char*>(&other->necp_fd_));
  swap(action_, other->action_);
}

::PROTOBUF_NAMESPACE_ID::Metadata NecpSessionAction::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[25]);
}

// ===================================================================

class NecpMatchPolicy::_Internal {
 public:
  using HasBits = decltype(std::declval<NecpMatchPolicy>()._has_bits_);
  static void set_has_parameters(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

NecpMatchPolicy::NecpMatchPolicy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:NecpMatchPolicy)
}
NecpMatchPolicy::NecpMatchPolicy(const NecpMatchPolicy& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  parameters_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_parameters()) {
    parameters_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_parameters(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:NecpMatchPolicy)
}

void NecpMatchPolicy::SharedCtor() {
parameters_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

NecpMatchPolicy::~NecpMatchPolicy() {
  // @@protoc_insertion_point(destructor:NecpMatchPolicy)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NecpMatchPolicy::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  parameters_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void NecpMatchPolicy::ArenaDtor(void* object) {
  NecpMatchPolicy* _this = reinterpret_cast< NecpMatchPolicy* >(object);
  (void)_this;
}
void NecpMatchPolicy::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NecpMatchPolicy::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NecpMatchPolicy::Clear() {
// @@protoc_insertion_point(message_clear_start:NecpMatchPolicy)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    parameters_.ClearNonDefaultToEmpty();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NecpMatchPolicy::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional bytes parameters = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_parameters();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NecpMatchPolicy::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:NecpMatchPolicy)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes parameters = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_parameters(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:NecpMatchPolicy)
  return target;
}

size_t NecpMatchPolicy::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:NecpMatchPolicy)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bytes parameters = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_parameters());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NecpMatchPolicy::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NecpMatchPolicy::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NecpMatchPolicy::GetClassData() const { return &_class_data_; }

void NecpMatchPolicy::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<NecpMatchPolicy *>(to)->MergeFrom(
      static_cast<const NecpMatchPolicy &>(from));
}


void NecpMatchPolicy::MergeFrom(const NecpMatchPolicy& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:NecpMatchPolicy)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_parameters()) {
    _internal_set_parameters(from._internal_parameters());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NecpMatchPolicy::CopyFrom(const NecpMatchPolicy& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:NecpMatchPolicy)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NecpMatchPolicy::IsInitialized() const {
  return true;
}

void NecpMatchPolicy::InternalSwap(NecpMatchPolicy* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &parameters_, lhs_arena,
      &other->parameters_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata NecpMatchPolicy::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[26]);
}

// ===================================================================

class NecpOpen::_Internal {
 public:
};

NecpOpen::NecpOpen(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  flags_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:NecpOpen)
}
NecpOpen::NecpOpen(const NecpOpen& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      flags_(from.flags_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:NecpOpen)
}

void NecpOpen::SharedCtor() {
}

NecpOpen::~NecpOpen() {
  // @@protoc_insertion_point(destructor:NecpOpen)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NecpOpen::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void NecpOpen::ArenaDtor(void* object) {
  NecpOpen* _this = reinterpret_cast< NecpOpen* >(object);
  (void)_this;
}
void NecpOpen::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NecpOpen::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NecpOpen::Clear() {
// @@protoc_insertion_point(message_clear_start:NecpOpen)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  flags_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NecpOpen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .NecpOpenFlag flags = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ptr -= 1;
          do {
            ptr += 1;
            ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
            if (PROTOBUF_PREDICT_TRUE(::NecpOpenFlag_IsValid(val))) {
              _internal_add_flags(static_cast<::NecpOpenFlag>(val));
            } else {
              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
            }
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(_internal_mutable_flags(), ptr, ctx, ::NecpOpenFlag_IsValid, &_internal_metadata_, 1);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NecpOpen::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:NecpOpen)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .NecpOpenFlag flags = 1;
  for (int i = 0, n = this->_internal_flags_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        1, this->_internal_flags(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:NecpOpen)
  return target;
}

size_t NecpOpen::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:NecpOpen)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .NecpOpenFlag flags = 1;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->_internal_flags_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
        this->_internal_flags(static_cast<int>(i)));
    }
    total_size += (1UL * count) + data_size;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NecpOpen::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NecpOpen::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NecpOpen::GetClassData() const { return &_class_data_; }

void NecpOpen::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<NecpOpen *>(to)->MergeFrom(
      static_cast<const NecpOpen &>(from));
}


void NecpOpen::MergeFrom(const NecpOpen& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:NecpOpen)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  flags_.MergeFrom(from.flags_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NecpOpen::CopyFrom(const NecpOpen& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:NecpOpen)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NecpOpen::IsInitialized() const {
  return true;
}

void NecpOpen::InternalSwap(NecpOpen* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  flags_.InternalSwap(&other->flags_);
}

::PROTOBUF_NAMESPACE_ID::Metadata NecpOpen::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[27]);
}

// ===================================================================

class NecpClientAction::_Internal {
 public:
  using HasBits = decltype(std::declval<NecpClientAction>()._has_bits_);
  static void set_has_necp_fd(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_client_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::NecpClientActionAdd& add(const NecpClientAction* msg);
  static const ::NecpClientActionRemove& remove(const NecpClientAction* msg);
  static const ::NecpClientActionCopyParameters& copy_parameters(const NecpClientAction* msg);
  static const ::NecpClientActionAgent& agent(const NecpClientAction* msg);
};

const ::NecpClientActionAdd&
NecpClientAction::_Internal::add(const NecpClientAction* msg) {
  return *msg->action_.add_;
}
const ::NecpClientActionRemove&
NecpClientAction::_Internal::remove(const NecpClientAction* msg) {
  return *msg->action_.remove_;
}
const ::NecpClientActionCopyParameters&
NecpClientAction::_Internal::copy_parameters(const NecpClientAction* msg) {
  return *msg->action_.copy_parameters_;
}
const ::NecpClientActionAgent&
NecpClientAction::_Internal::agent(const NecpClientAction* msg) {
  return *msg->action_.agent_;
}
void NecpClientAction::set_allocated_add(::NecpClientActionAdd* add) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_action();
  if (add) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::NecpClientActionAdd>::GetOwningArena(add);
    if (message_arena != submessage_arena) {
      add = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, add, submessage_arena);
    }
    set_has_add();
    action_.add_ = add;
  }
  // @@protoc_insertion_point(field_set_allocated:NecpClientAction.add)
}
void NecpClientAction::set_allocated_remove(::NecpClientActionRemove* remove) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_action();
  if (remove) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::NecpClientActionRemove>::GetOwningArena(remove);
    if (message_arena != submessage_arena) {
      remove = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, remove, submessage_arena);
    }
    set_has_remove();
    action_.remove_ = remove;
  }
  // @@protoc_insertion_point(field_set_allocated:NecpClientAction.remove)
}
void NecpClientAction::set_allocated_copy_parameters(::NecpClientActionCopyParameters* copy_parameters) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_action();
  if (copy_parameters) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::NecpClientActionCopyParameters>::GetOwningArena(copy_parameters);
    if (message_arena != submessage_arena) {
      copy_parameters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, copy_parameters, submessage_arena);
    }
    set_has_copy_parameters();
    action_.copy_parameters_ = copy_parameters;
  }
  // @@protoc_insertion_point(field_set_allocated:NecpClientAction.copy_parameters)
}
void NecpClientAction::set_allocated_agent(::NecpClientActionAgent* agent) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_action();
  if (agent) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::NecpClientActionAgent>::GetOwningArena(agent);
    if (message_arena != submessage_arena) {
      agent = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, agent, submessage_arena);
    }
    set_has_agent();
    action_.agent_ = agent;
  }
  // @@protoc_insertion_point(field_set_allocated:NecpClientAction.agent)
}
NecpClientAction::NecpClientAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:NecpClientAction)
}
NecpClientAction::NecpClientAction(const NecpClientAction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&necp_fd_, &from.necp_fd_,
    static_cast<size_t>(reinterpret_cast<char*>(&client_id_) -
    reinterpret_cast<char*>(&necp_fd_)) + sizeof(client_id_));
  clear_has_action();
  switch (from.action_case()) {
    case kAdd: {
      _internal_mutable_add()->::NecpClientActionAdd::MergeFrom(from._internal_add());
      break;
    }
    case kRemove: {
      _internal_mutable_remove()->::NecpClientActionRemove::MergeFrom(from._internal_remove());
      break;
    }
    case kCopyParameters: {
      _internal_mutable_copy_parameters()->::NecpClientActionCopyParameters::MergeFrom(from._internal_copy_parameters());
      break;
    }
    case kAgent: {
      _internal_mutable_agent()->::NecpClientActionAgent::MergeFrom(from._internal_agent());
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:NecpClientAction)
}

void NecpClientAction::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&necp_fd_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&client_id_) -
    reinterpret_cast<char*>(&necp_fd_)) + sizeof(client_id_));
clear_has_action();
}

NecpClientAction::~NecpClientAction() {
  // @@protoc_insertion_point(destructor:NecpClientAction)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NecpClientAction::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_action()) {
    clear_action();
  }
}

void NecpClientAction::ArenaDtor(void* object) {
  NecpClientAction* _this = reinterpret_cast< NecpClientAction* >(object);
  (void)_this;
}
void NecpClientAction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NecpClientAction::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NecpClientAction::clear_action() {
// @@protoc_insertion_point(one_of_clear_start:NecpClientAction)
  switch (action_case()) {
    case kAdd: {
      if (GetArenaForAllocation() == nullptr) {
        delete action_.add_;
      }
      break;
    }
    case kRemove: {
      if (GetArenaForAllocation() == nullptr) {
        delete action_.remove_;
      }
      break;
    }
    case kCopyParameters: {
      if (GetArenaForAllocation() == nullptr) {
        delete action_.copy_parameters_;
      }
      break;
    }
    case kAgent: {
      if (GetArenaForAllocation() == nullptr) {
        delete action_.agent_;
      }
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = ACTION_NOT_SET;
}


void NecpClientAction::Clear() {
// @@protoc_insertion_point(message_clear_start:NecpClientAction)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&necp_fd_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&client_id_) -
        reinterpret_cast<char*>(&necp_fd_)) + sizeof(client_id_));
  }
  clear_action();
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NecpClientAction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .FileDescriptor necp_fd = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_necp_fd(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .NecpClientId client_id = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::NecpClientId_IsValid(val))) {
            _internal_set_client_id(static_cast<::NecpClientId>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // .NecpClientActionAdd add = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_add(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .NecpClientActionRemove remove = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_remove(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .NecpClientActionCopyParameters copy_parameters = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_copy_parameters(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .NecpClientActionAgent agent = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_agent(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NecpClientAction::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:NecpClientAction)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor necp_fd = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_necp_fd(), target);
  }

  // optional .NecpClientId client_id = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_client_id(), target);
  }

  switch (action_case()) {
    case kAdd: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          5, _Internal::add(this), target, stream);
      break;
    }
    case kRemove: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          6, _Internal::remove(this), target, stream);
      break;
    }
    case kCopyParameters: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          7, _Internal::copy_parameters(this), target, stream);
      break;
    }
    case kAgent: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          11, _Internal::agent(this), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:NecpClientAction)
  return target;
}

size_t NecpClientAction::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:NecpClientAction)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .FileDescriptor necp_fd = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_necp_fd());
    }

    // optional .NecpClientId client_id = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_client_id());
    }

  }
  switch (action_case()) {
    // .NecpClientActionAdd add = 5;
    case kAdd: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.add_);
      break;
    }
    // .NecpClientActionRemove remove = 6;
    case kRemove: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.remove_);
      break;
    }
    // .NecpClientActionCopyParameters copy_parameters = 7;
    case kCopyParameters: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.copy_parameters_);
      break;
    }
    // .NecpClientActionAgent agent = 11;
    case kAgent: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.agent_);
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NecpClientAction::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NecpClientAction::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NecpClientAction::GetClassData() const { return &_class_data_; }

void NecpClientAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<NecpClientAction *>(to)->MergeFrom(
      static_cast<const NecpClientAction &>(from));
}


void NecpClientAction::MergeFrom(const NecpClientAction& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:NecpClientAction)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      necp_fd_ = from.necp_fd_;
    }
    if (cached_has_bits & 0x00000002u) {
      client_id_ = from.client_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.action_case()) {
    case kAdd: {
      _internal_mutable_add()->::NecpClientActionAdd::MergeFrom(from._internal_add());
      break;
    }
    case kRemove: {
      _internal_mutable_remove()->::NecpClientActionRemove::MergeFrom(from._internal_remove());
      break;
    }
    case kCopyParameters: {
      _internal_mutable_copy_parameters()->::NecpClientActionCopyParameters::MergeFrom(from._internal_copy_parameters());
      break;
    }
    case kAgent: {
      _internal_mutable_agent()->::NecpClientActionAgent::MergeFrom(from._internal_agent());
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NecpClientAction::CopyFrom(const NecpClientAction& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:NecpClientAction)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NecpClientAction::IsInitialized() const {
  return true;
}

void NecpClientAction::InternalSwap(NecpClientAction* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(NecpClientAction, client_id_)
      + sizeof(NecpClientAction::client_id_)
      - PROTOBUF_FIELD_OFFSET(NecpClientAction, necp_fd_)>(
          reinterpret_cast<char*>(&necp_fd_),
          reinterpret_cast<char*>(&other->necp_fd_));
  swap(action_, other->action_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata NecpClientAction::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[28]);
}

// ===================================================================

class NecpClientActionAdd::_Internal {
 public:
  using HasBits = decltype(std::declval<NecpClientActionAdd>()._has_bits_);
  static void set_has_buffer(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

NecpClientActionAdd::NecpClientActionAdd(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:NecpClientActionAdd)
}
NecpClientActionAdd::NecpClientActionAdd(const NecpClientActionAdd& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  buffer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_buffer()) {
    buffer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_buffer(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:NecpClientActionAdd)
}

void NecpClientActionAdd::SharedCtor() {
buffer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

NecpClientActionAdd::~NecpClientActionAdd() {
  // @@protoc_insertion_point(destructor:NecpClientActionAdd)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NecpClientActionAdd::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  buffer_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void NecpClientActionAdd::ArenaDtor(void* object) {
  NecpClientActionAdd* _this = reinterpret_cast< NecpClientActionAdd* >(object);
  (void)_this;
}
void NecpClientActionAdd::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NecpClientActionAdd::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NecpClientActionAdd::Clear() {
// @@protoc_insertion_point(message_clear_start:NecpClientActionAdd)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    buffer_.ClearNonDefaultToEmpty();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NecpClientActionAdd::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional bytes buffer = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_buffer();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NecpClientActionAdd::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:NecpClientActionAdd)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes buffer = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_buffer(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:NecpClientActionAdd)
  return target;
}

size_t NecpClientActionAdd::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:NecpClientActionAdd)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bytes buffer = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_buffer());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NecpClientActionAdd::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NecpClientActionAdd::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NecpClientActionAdd::GetClassData() const { return &_class_data_; }

void NecpClientActionAdd::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<NecpClientActionAdd *>(to)->MergeFrom(
      static_cast<const NecpClientActionAdd &>(from));
}


void NecpClientActionAdd::MergeFrom(const NecpClientActionAdd& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:NecpClientActionAdd)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_buffer()) {
    _internal_set_buffer(from._internal_buffer());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NecpClientActionAdd::CopyFrom(const NecpClientActionAdd& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:NecpClientActionAdd)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NecpClientActionAdd::IsInitialized() const {
  return true;
}

void NecpClientActionAdd::InternalSwap(NecpClientActionAdd* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &buffer_, lhs_arena,
      &other->buffer_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata NecpClientActionAdd::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[29]);
}

// ===================================================================

class NecpClientActionRemove::_Internal {
 public:
};

NecpClientActionRemove::NecpClientActionRemove(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:NecpClientActionRemove)
}
NecpClientActionRemove::NecpClientActionRemove(const NecpClientActionRemove& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:NecpClientActionRemove)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NecpClientActionRemove::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NecpClientActionRemove::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata NecpClientActionRemove::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[30]);
}

// ===================================================================

class NecpClientActionCopyParameters::_Internal {
 public:
  using HasBits = decltype(std::declval<NecpClientActionCopyParameters>()._has_bits_);
  static void set_has_copyout_size(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

NecpClientActionCopyParameters::NecpClientActionCopyParameters(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:NecpClientActionCopyParameters)
}
NecpClientActionCopyParameters::NecpClientActionCopyParameters(const NecpClientActionCopyParameters& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  copyout_size_ = from.copyout_size_;
  // @@protoc_insertion_point(copy_constructor:NecpClientActionCopyParameters)
}

void NecpClientActionCopyParameters::SharedCtor() {
copyout_size_ = 0u;
}

NecpClientActionCopyParameters::~NecpClientActionCopyParameters() {
  // @@protoc_insertion_point(destructor:NecpClientActionCopyParameters)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NecpClientActionCopyParameters::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void NecpClientActionCopyParameters::ArenaDtor(void* object) {
  NecpClientActionCopyParameters* _this = reinterpret_cast< NecpClientActionCopyParameters* >(object);
  (void)_this;
}
void NecpClientActionCopyParameters::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NecpClientActionCopyParameters::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NecpClientActionCopyParameters::Clear() {
// @@protoc_insertion_point(message_clear_start:NecpClientActionCopyParameters)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  copyout_size_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NecpClientActionCopyParameters::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional uint32 copyout_size = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_copyout_size(&has_bits);
          copyout_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NecpClientActionCopyParameters::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:NecpClientActionCopyParameters)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 copyout_size = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_copyout_size(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:NecpClientActionCopyParameters)
  return target;
}

size_t NecpClientActionCopyParameters::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:NecpClientActionCopyParameters)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint32 copyout_size = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_copyout_size());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NecpClientActionCopyParameters::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NecpClientActionCopyParameters::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NecpClientActionCopyParameters::GetClassData() const { return &_class_data_; }

void NecpClientActionCopyParameters::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<NecpClientActionCopyParameters *>(to)->MergeFrom(
      static_cast<const NecpClientActionCopyParameters &>(from));
}


void NecpClientActionCopyParameters::MergeFrom(const NecpClientActionCopyParameters& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:NecpClientActionCopyParameters)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_copyout_size()) {
    _internal_set_copyout_size(from._internal_copyout_size());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NecpClientActionCopyParameters::CopyFrom(const NecpClientActionCopyParameters& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:NecpClientActionCopyParameters)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NecpClientActionCopyParameters::IsInitialized() const {
  return true;
}

void NecpClientActionCopyParameters::InternalSwap(NecpClientActionCopyParameters* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(copyout_size_, other->copyout_size_);
}

::PROTOBUF_NAMESPACE_ID::Metadata NecpClientActionCopyParameters::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[31]);
}

// ===================================================================

class NecpClientActionAgent::_Internal {
 public:
};

NecpClientActionAgent::NecpClientActionAgent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  necp_tlv_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:NecpClientActionAgent)
}
NecpClientActionAgent::NecpClientActionAgent(const NecpClientActionAgent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      necp_tlv_(from.necp_tlv_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:NecpClientActionAgent)
}

void NecpClientActionAgent::SharedCtor() {
}

NecpClientActionAgent::~NecpClientActionAgent() {
  // @@protoc_insertion_point(destructor:NecpClientActionAgent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NecpClientActionAgent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void NecpClientActionAgent::ArenaDtor(void* object) {
  NecpClientActionAgent* _this = reinterpret_cast< NecpClientActionAgent* >(object);
  (void)_this;
}
void NecpClientActionAgent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NecpClientActionAgent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NecpClientActionAgent::Clear() {
// @@protoc_insertion_point(message_clear_start:NecpClientActionAgent)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  necp_tlv_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NecpClientActionAgent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .NecpTlv necp_tlv = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_necp_tlv(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NecpClientActionAgent::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:NecpClientActionAgent)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .NecpTlv necp_tlv = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_necp_tlv_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_necp_tlv(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:NecpClientActionAgent)
  return target;
}

size_t NecpClientActionAgent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:NecpClientActionAgent)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .NecpTlv necp_tlv = 1;
  total_size += 1UL * this->_internal_necp_tlv_size();
  for (const auto& msg : this->necp_tlv_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NecpClientActionAgent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NecpClientActionAgent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NecpClientActionAgent::GetClassData() const { return &_class_data_; }

void NecpClientActionAgent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<NecpClientActionAgent *>(to)->MergeFrom(
      static_cast<const NecpClientActionAgent &>(from));
}


void NecpClientActionAgent::MergeFrom(const NecpClientActionAgent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:NecpClientActionAgent)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  necp_tlv_.MergeFrom(from.necp_tlv_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NecpClientActionAgent::CopyFrom(const NecpClientActionAgent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:NecpClientActionAgent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NecpClientActionAgent::IsInitialized() const {
  return true;
}

void NecpClientActionAgent::InternalSwap(NecpClientActionAgent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  necp_tlv_.InternalSwap(&other->necp_tlv_);
}

::PROTOBUF_NAMESPACE_ID::Metadata NecpClientActionAgent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[32]);
}

// ===================================================================

class NecpTlv::_Internal {
 public:
  using HasBits = decltype(std::declval<NecpTlv>()._has_bits_);
  static void set_has_necp_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

NecpTlv::NecpTlv(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:NecpTlv)
}
NecpTlv::NecpTlv(const NecpTlv& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data()) {
    data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), 
      GetArenaForAllocation());
  }
  necp_type_ = from.necp_type_;
  // @@protoc_insertion_point(copy_constructor:NecpTlv)
}

void NecpTlv::SharedCtor() {
data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
necp_type_ = 0u;
}

NecpTlv::~NecpTlv() {
  // @@protoc_insertion_point(destructor:NecpTlv)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NecpTlv::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void NecpTlv::ArenaDtor(void* object) {
  NecpTlv* _this = reinterpret_cast< NecpTlv* >(object);
  (void)_this;
}
void NecpTlv::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NecpTlv::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NecpTlv::Clear() {
// @@protoc_insertion_point(message_clear_start:NecpTlv)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    data_.ClearNonDefaultToEmpty();
  }
  necp_type_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NecpTlv::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional uint32 necp_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_necp_type(&has_bits);
          necp_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bytes data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NecpTlv::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:NecpTlv)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 necp_type = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_necp_type(), target);
  }

  // optional bytes data = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:NecpTlv)
  return target;
}

size_t NecpTlv::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:NecpTlv)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional bytes data = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_data());
    }

    // optional uint32 necp_type = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_necp_type());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NecpTlv::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NecpTlv::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NecpTlv::GetClassData() const { return &_class_data_; }

void NecpTlv::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<NecpTlv *>(to)->MergeFrom(
      static_cast<const NecpTlv &>(from));
}


void NecpTlv::MergeFrom(const NecpTlv& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:NecpTlv)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_data(from._internal_data());
    }
    if (cached_has_bits & 0x00000002u) {
      necp_type_ = from.necp_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NecpTlv::CopyFrom(const NecpTlv& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:NecpTlv)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NecpTlv::IsInitialized() const {
  return true;
}

void NecpTlv::InternalSwap(NecpTlv* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &data_, lhs_arena,
      &other->data_, rhs_arena
  );
  swap(necp_type_, other->necp_type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata NecpTlv::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[33]);
}

// ===================================================================

class ClearAll::_Internal {
 public:
};

ClearAll::ClearAll(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:ClearAll)
}
ClearAll::ClearAll(const ClearAll& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:ClearAll)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClearAll::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClearAll::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata ClearAll::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[34]);
}

// ===================================================================

class Close::_Internal {
 public:
  using HasBits = decltype(std::declval<Close>()._has_bits_);
  static void set_has_fd(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

Close::Close(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Close)
}
Close::Close(const Close& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  fd_ = from.fd_;
  // @@protoc_insertion_point(copy_constructor:Close)
}

void Close::SharedCtor() {
fd_ = 0;
}

Close::~Close() {
  // @@protoc_insertion_point(destructor:Close)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Close::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Close::ArenaDtor(void* object) {
  Close* _this = reinterpret_cast< Close* >(object);
  (void)_this;
}
void Close::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Close::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Close::Clear() {
// @@protoc_insertion_point(message_clear_start:Close)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  fd_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Close::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .FileDescriptor fd = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_fd(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Close::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Close)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .FileDescriptor fd = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_fd(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Close)
  return target;
}

size_t Close::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Close)
  size_t total_size = 0;

  // required .FileDescriptor fd = 1;
  if (_internal_has_fd()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fd());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Close::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Close::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Close::GetClassData() const { return &_class_data_; }

void Close::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Close *>(to)->MergeFrom(
      static_cast<const Close &>(from));
}


void Close::MergeFrom(const Close& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Close)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_fd()) {
    _internal_set_fd(from._internal_fd());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Close::CopyFrom(const Close& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Close)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Close::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void Close::InternalSwap(Close* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(fd_, other->fd_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Close::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[35]);
}

// ===================================================================

class Accept::_Internal {
 public:
  using HasBits = decltype(std::declval<Accept>()._has_bits_);
  static const ::SockAddr& sockaddr(const Accept* msg);
  static void set_has_sockaddr(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_fd(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

const ::SockAddr&
Accept::_Internal::sockaddr(const Accept* msg) {
  return *msg->sockaddr_;
}
Accept::Accept(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Accept)
}
Accept::Accept(const Accept& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_sockaddr()) {
    sockaddr_ = new ::SockAddr(*from.sockaddr_);
  } else {
    sockaddr_ = nullptr;
  }
  fd_ = from.fd_;
  // @@protoc_insertion_point(copy_constructor:Accept)
}

void Accept::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&sockaddr_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&fd_) -
    reinterpret_cast<char*>(&sockaddr_)) + sizeof(fd_));
}

Accept::~Accept() {
  // @@protoc_insertion_point(destructor:Accept)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Accept::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete sockaddr_;
}

void Accept::ArenaDtor(void* object) {
  Accept* _this = reinterpret_cast< Accept* >(object);
  (void)_this;
}
void Accept::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Accept::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Accept::Clear() {
// @@protoc_insertion_point(message_clear_start:Accept)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(sockaddr_ != nullptr);
    sockaddr_->Clear();
  }
  fd_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Accept::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .SockAddr sockaddr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_sockaddr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .FileDescriptor fd = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_fd(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Accept::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Accept)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .SockAddr sockaddr = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::sockaddr(this), target, stream);
  }

  // optional .FileDescriptor fd = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_fd(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Accept)
  return target;
}

size_t Accept::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Accept)
  size_t total_size = 0;

  // required .SockAddr sockaddr = 1;
  if (_internal_has_sockaddr()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *sockaddr_);
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .FileDescriptor fd = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000002u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fd());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Accept::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Accept::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Accept::GetClassData() const { return &_class_data_; }

void Accept::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Accept *>(to)->MergeFrom(
      static_cast<const Accept &>(from));
}


void Accept::MergeFrom(const Accept& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Accept)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_sockaddr()->::SockAddr::MergeFrom(from._internal_sockaddr());
    }
    if (cached_has_bits & 0x00000002u) {
      fd_ = from.fd_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Accept::CopyFrom(const Accept& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Accept)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Accept::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_sockaddr()) {
    if (!sockaddr_->IsInitialized()) return false;
  }
  return true;
}

void Accept::InternalSwap(Accept* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Accept, fd_)
      + sizeof(Accept::fd_)
      - PROTOBUF_FIELD_OFFSET(Accept, sockaddr_)>(
          reinterpret_cast<char*>(&sockaddr_),
          reinterpret_cast<char*>(&other->sockaddr_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Accept::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[36]);
}

// ===================================================================

class Bind::_Internal {
 public:
  using HasBits = decltype(std::declval<Bind>()._has_bits_);
  static const ::SockAddr& sockaddr(const Bind* msg);
  static void set_has_sockaddr(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_fd(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

const ::SockAddr&
Bind::_Internal::sockaddr(const Bind* msg) {
  return *msg->sockaddr_;
}
Bind::Bind(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Bind)
}
Bind::Bind(const Bind& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_sockaddr()) {
    sockaddr_ = new ::SockAddr(*from.sockaddr_);
  } else {
    sockaddr_ = nullptr;
  }
  fd_ = from.fd_;
  // @@protoc_insertion_point(copy_constructor:Bind)
}

void Bind::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&sockaddr_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&fd_) -
    reinterpret_cast<char*>(&sockaddr_)) + sizeof(fd_));
}

Bind::~Bind() {
  // @@protoc_insertion_point(destructor:Bind)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Bind::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete sockaddr_;
}

void Bind::ArenaDtor(void* object) {
  Bind* _this = reinterpret_cast< Bind* >(object);
  (void)_this;
}
void Bind::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Bind::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Bind::Clear() {
// @@protoc_insertion_point(message_clear_start:Bind)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(sockaddr_ != nullptr);
    sockaddr_->Clear();
  }
  fd_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Bind::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .SockAddr sockaddr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_sockaddr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .FileDescriptor fd = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_fd(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Bind::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Bind)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .SockAddr sockaddr = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::sockaddr(this), target, stream);
  }

  // optional .FileDescriptor fd = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_fd(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Bind)
  return target;
}

size_t Bind::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Bind)
  size_t total_size = 0;

  // required .SockAddr sockaddr = 1;
  if (_internal_has_sockaddr()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *sockaddr_);
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .FileDescriptor fd = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000002u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fd());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Bind::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Bind::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Bind::GetClassData() const { return &_class_data_; }

void Bind::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Bind *>(to)->MergeFrom(
      static_cast<const Bind &>(from));
}


void Bind::MergeFrom(const Bind& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Bind)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_sockaddr()->::SockAddr::MergeFrom(from._internal_sockaddr());
    }
    if (cached_has_bits & 0x00000002u) {
      fd_ = from.fd_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Bind::CopyFrom(const Bind& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Bind)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Bind::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_sockaddr()) {
    if (!sockaddr_->IsInitialized()) return false;
  }
  return true;
}

void Bind::InternalSwap(Bind* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Bind, fd_)
      + sizeof(Bind::fd_)
      - PROTOBUF_FIELD_OFFSET(Bind, sockaddr_)>(
          reinterpret_cast<char*>(&sockaddr_),
          reinterpret_cast<char*>(&other->sockaddr_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Bind::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[37]);
}

// ===================================================================

class Listen::_Internal {
 public:
  using HasBits = decltype(std::declval<Listen>()._has_bits_);
  static void set_has_socket(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_backlog(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

Listen::Listen(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Listen)
}
Listen::Listen(const Listen& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&socket_, &from.socket_,
    static_cast<size_t>(reinterpret_cast<char*>(&backlog_) -
    reinterpret_cast<char*>(&socket_)) + sizeof(backlog_));
  // @@protoc_insertion_point(copy_constructor:Listen)
}

void Listen::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&socket_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&backlog_) -
    reinterpret_cast<char*>(&socket_)) + sizeof(backlog_));
}

Listen::~Listen() {
  // @@protoc_insertion_point(destructor:Listen)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Listen::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Listen::ArenaDtor(void* object) {
  Listen* _this = reinterpret_cast< Listen* >(object);
  (void)_this;
}
void Listen::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Listen::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Listen::Clear() {
// @@protoc_insertion_point(message_clear_start:Listen)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&socket_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&backlog_) -
        reinterpret_cast<char*>(&socket_)) + sizeof(backlog_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Listen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .FileDescriptor socket = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_socket(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional int32 backlog = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_backlog(&has_bits);
          backlog_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Listen::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Listen)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .FileDescriptor socket = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_socket(), target);
  }

  // optional int32 backlog = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_backlog(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Listen)
  return target;
}

size_t Listen::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Listen)
  size_t total_size = 0;

  // required .FileDescriptor socket = 1;
  if (_internal_has_socket()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_socket());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional int32 backlog = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000002u) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_backlog());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Listen::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Listen::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Listen::GetClassData() const { return &_class_data_; }

void Listen::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Listen *>(to)->MergeFrom(
      static_cast<const Listen &>(from));
}


void Listen::MergeFrom(const Listen& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Listen)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      socket_ = from.socket_;
    }
    if (cached_has_bits & 0x00000002u) {
      backlog_ = from.backlog_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Listen::CopyFrom(const Listen& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Listen)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Listen::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void Listen::InternalSwap(Listen* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Listen, backlog_)
      + sizeof(Listen::backlog_)
      - PROTOBUF_FIELD_OFFSET(Listen, socket_)>(
          reinterpret_cast<char*>(&socket_),
          reinterpret_cast<char*>(&other->socket_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Listen::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[38]);
}

// ===================================================================

class IoctlReal::_Internal {
 public:
  using HasBits = decltype(std::declval<IoctlReal>()._has_bits_);
  static const ::In6_AliasReq_64& siocaifaddr_in6_64(const IoctlReal* msg);
  static const ::IfReqFlags& siocsifflags(const IoctlReal* msg);
  static void set_has_fd(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::In6_AliasReq_64&
IoctlReal::_Internal::siocaifaddr_in6_64(const IoctlReal* msg) {
  return *msg->ioctl_.siocaifaddr_in6_64_;
}
const ::IfReqFlags&
IoctlReal::_Internal::siocsifflags(const IoctlReal* msg) {
  return *msg->ioctl_.siocsifflags_;
}
void IoctlReal::set_allocated_siocaifaddr_in6_64(::In6_AliasReq_64* siocaifaddr_in6_64) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_ioctl();
  if (siocaifaddr_in6_64) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::In6_AliasReq_64>::GetOwningArena(siocaifaddr_in6_64);
    if (message_arena != submessage_arena) {
      siocaifaddr_in6_64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, siocaifaddr_in6_64, submessage_arena);
    }
    set_has_siocaifaddr_in6_64();
    ioctl_.siocaifaddr_in6_64_ = siocaifaddr_in6_64;
  }
  // @@protoc_insertion_point(field_set_allocated:IoctlReal.siocaifaddr_in6_64)
}
void IoctlReal::set_allocated_siocsifflags(::IfReqFlags* siocsifflags) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_ioctl();
  if (siocsifflags) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::IfReqFlags>::GetOwningArena(siocsifflags);
    if (message_arena != submessage_arena) {
      siocsifflags = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, siocsifflags, submessage_arena);
    }
    set_has_siocsifflags();
    ioctl_.siocsifflags_ = siocsifflags;
  }
  // @@protoc_insertion_point(field_set_allocated:IoctlReal.siocsifflags)
}
IoctlReal::IoctlReal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:IoctlReal)
}
IoctlReal::IoctlReal(const IoctlReal& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  fd_ = from.fd_;
  clear_has_ioctl();
  switch (from.ioctl_case()) {
    case kSiocaifaddrIn664: {
      _internal_mutable_siocaifaddr_in6_64()->::In6_AliasReq_64::MergeFrom(from._internal_siocaifaddr_in6_64());
      break;
    }
    case kSiocsifflags: {
      _internal_mutable_siocsifflags()->::IfReqFlags::MergeFrom(from._internal_siocsifflags());
      break;
    }
    case IOCTL_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:IoctlReal)
}

void IoctlReal::SharedCtor() {
fd_ = 0;
clear_has_ioctl();
}

IoctlReal::~IoctlReal() {
  // @@protoc_insertion_point(destructor:IoctlReal)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void IoctlReal::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_ioctl()) {
    clear_ioctl();
  }
}

void IoctlReal::ArenaDtor(void* object) {
  IoctlReal* _this = reinterpret_cast< IoctlReal* >(object);
  (void)_this;
}
void IoctlReal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void IoctlReal::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void IoctlReal::clear_ioctl() {
// @@protoc_insertion_point(one_of_clear_start:IoctlReal)
  switch (ioctl_case()) {
    case kSiocaifaddrIn664: {
      if (GetArenaForAllocation() == nullptr) {
        delete ioctl_.siocaifaddr_in6_64_;
      }
      break;
    }
    case kSiocsifflags: {
      if (GetArenaForAllocation() == nullptr) {
        delete ioctl_.siocsifflags_;
      }
      break;
    }
    case IOCTL_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = IOCTL_NOT_SET;
}


void IoctlReal::Clear() {
// @@protoc_insertion_point(message_clear_start:IoctlReal)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  fd_ = 0;
  clear_ioctl();
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* IoctlReal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .In6_AliasReq_64 siocaifaddr_in6_64 = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_siocaifaddr_in6_64(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .FileDescriptor fd = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_fd(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // .IfReqFlags siocsifflags = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_siocsifflags(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* IoctlReal::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:IoctlReal)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .In6_AliasReq_64 siocaifaddr_in6_64 = 1;
  if (_internal_has_siocaifaddr_in6_64()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::siocaifaddr_in6_64(this), target, stream);
  }

  cached_has_bits = _has_bits_[0];
  // optional .FileDescriptor fd = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_fd(), target);
  }

  // .IfReqFlags siocsifflags = 3;
  if (_internal_has_siocsifflags()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::siocsifflags(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:IoctlReal)
  return target;
}

size_t IoctlReal::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:IoctlReal)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .FileDescriptor fd = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fd());
  }

  switch (ioctl_case()) {
    // .In6_AliasReq_64 siocaifaddr_in6_64 = 1;
    case kSiocaifaddrIn664: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *ioctl_.siocaifaddr_in6_64_);
      break;
    }
    // .IfReqFlags siocsifflags = 3;
    case kSiocsifflags: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *ioctl_.siocsifflags_);
      break;
    }
    case IOCTL_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData IoctlReal::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    IoctlReal::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*IoctlReal::GetClassData() const { return &_class_data_; }

void IoctlReal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<IoctlReal *>(to)->MergeFrom(
      static_cast<const IoctlReal &>(from));
}


void IoctlReal::MergeFrom(const IoctlReal& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:IoctlReal)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_fd()) {
    _internal_set_fd(from._internal_fd());
  }
  switch (from.ioctl_case()) {
    case kSiocaifaddrIn664: {
      _internal_mutable_siocaifaddr_in6_64()->::In6_AliasReq_64::MergeFrom(from._internal_siocaifaddr_in6_64());
      break;
    }
    case kSiocsifflags: {
      _internal_mutable_siocsifflags()->::IfReqFlags::MergeFrom(from._internal_siocsifflags());
      break;
    }
    case IOCTL_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void IoctlReal::CopyFrom(const IoctlReal& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:IoctlReal)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool IoctlReal::IsInitialized() const {
  switch (ioctl_case()) {
    case kSiocaifaddrIn664: {
      if (has_siocaifaddr_in6_64()) {
        if (!this->siocaifaddr_in6_64().IsInitialized()) return false;
      }
      break;
    }
    case kSiocsifflags: {
      if (has_siocsifflags()) {
        if (!this->siocsifflags().IsInitialized()) return false;
      }
      break;
    }
    case IOCTL_NOT_SET: {
      break;
    }
  }
  return true;
}

void IoctlReal::InternalSwap(IoctlReal* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(fd_, other->fd_);
  swap(ioctl_, other->ioctl_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata IoctlReal::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[39]);
}

// ===================================================================

class IfReqFlags::_Internal {
 public:
  using HasBits = decltype(std::declval<IfReqFlags>()._has_bits_);
  static void set_has_ifr_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

IfReqFlags::IfReqFlags(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  flags_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:IfReqFlags)
}
IfReqFlags::IfReqFlags(const IfReqFlags& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      flags_(from.flags_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ifr_name_ = from.ifr_name_;
  // @@protoc_insertion_point(copy_constructor:IfReqFlags)
}

void IfReqFlags::SharedCtor() {
ifr_name_ = 0;
}

IfReqFlags::~IfReqFlags() {
  // @@protoc_insertion_point(destructor:IfReqFlags)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void IfReqFlags::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void IfReqFlags::ArenaDtor(void* object) {
  IfReqFlags* _this = reinterpret_cast< IfReqFlags* >(object);
  (void)_this;
}
void IfReqFlags::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void IfReqFlags::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void IfReqFlags::Clear() {
// @@protoc_insertion_point(message_clear_start:IfReqFlags)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  flags_.Clear();
  ifr_name_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* IfReqFlags::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .IfrName ifr_name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::IfrName_IsValid(val))) {
            _internal_set_ifr_name(static_cast<::IfrName>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // repeated .IfruFlag flags = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ptr -= 1;
          do {
            ptr += 1;
            ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
            if (PROTOBUF_PREDICT_TRUE(::IfruFlag_IsValid(val))) {
              _internal_add_flags(static_cast<::IfruFlag>(val));
            } else {
              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
            }
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(_internal_mutable_flags(), ptr, ctx, ::IfruFlag_IsValid, &_internal_metadata_, 2);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* IfReqFlags::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:IfReqFlags)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .IfrName ifr_name = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_ifr_name(), target);
  }

  // repeated .IfruFlag flags = 2;
  for (int i = 0, n = this->_internal_flags_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        2, this->_internal_flags(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:IfReqFlags)
  return target;
}

size_t IfReqFlags::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:IfReqFlags)
  size_t total_size = 0;

  // required .IfrName ifr_name = 1;
  if (_internal_has_ifr_name()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ifr_name());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .IfruFlag flags = 2;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->_internal_flags_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
        this->_internal_flags(static_cast<int>(i)));
    }
    total_size += (1UL * count) + data_size;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData IfReqFlags::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    IfReqFlags::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*IfReqFlags::GetClassData() const { return &_class_data_; }

void IfReqFlags::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<IfReqFlags *>(to)->MergeFrom(
      static_cast<const IfReqFlags &>(from));
}


void IfReqFlags::MergeFrom(const IfReqFlags& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:IfReqFlags)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  flags_.MergeFrom(from.flags_);
  if (from._internal_has_ifr_name()) {
    _internal_set_ifr_name(from._internal_ifr_name());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void IfReqFlags::CopyFrom(const IfReqFlags& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:IfReqFlags)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool IfReqFlags::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void IfReqFlags::InternalSwap(IfReqFlags* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  flags_.InternalSwap(&other->flags_);
  swap(ifr_name_, other->ifr_name_);
}

::PROTOBUF_NAMESPACE_ID::Metadata IfReqFlags::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[40]);
}

// ===================================================================

class In6_AliasReq_64::_Internal {
 public:
  using HasBits = decltype(std::declval<In6_AliasReq_64>()._has_bits_);
  static void set_has_ifra_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SockAddr6& ifra_addr(const In6_AliasReq_64* msg);
  static void set_has_ifra_addr(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::SockAddr6& ifra_dstaddr(const In6_AliasReq_64* msg);
  static void set_has_ifra_dstaddr(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SockAddr6& ifra_prefixmask(const In6_AliasReq_64* msg);
  static void set_has_ifra_prefixmask(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::In6AddrLifetime_64& ifra_lifetime(const In6_AliasReq_64* msg);
  static void set_has_ifra_lifetime(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000001f) ^ 0x0000001f) != 0;
  }
};

const ::SockAddr6&
In6_AliasReq_64::_Internal::ifra_addr(const In6_AliasReq_64* msg) {
  return *msg->ifra_addr_;
}
const ::SockAddr6&
In6_AliasReq_64::_Internal::ifra_dstaddr(const In6_AliasReq_64* msg) {
  return *msg->ifra_dstaddr_;
}
const ::SockAddr6&
In6_AliasReq_64::_Internal::ifra_prefixmask(const In6_AliasReq_64* msg) {
  return *msg->ifra_prefixmask_;
}
const ::In6AddrLifetime_64&
In6_AliasReq_64::_Internal::ifra_lifetime(const In6_AliasReq_64* msg) {
  return *msg->ifra_lifetime_;
}
In6_AliasReq_64::In6_AliasReq_64(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  ifra_flags_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:In6_AliasReq_64)
}
In6_AliasReq_64::In6_AliasReq_64(const In6_AliasReq_64& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      ifra_flags_(from.ifra_flags_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ifra_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_ifra_name()) {
    ifra_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_ifra_name(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_ifra_addr()) {
    ifra_addr_ = new ::SockAddr6(*from.ifra_addr_);
  } else {
    ifra_addr_ = nullptr;
  }
  if (from._internal_has_ifra_dstaddr()) {
    ifra_dstaddr_ = new ::SockAddr6(*from.ifra_dstaddr_);
  } else {
    ifra_dstaddr_ = nullptr;
  }
  if (from._internal_has_ifra_prefixmask()) {
    ifra_prefixmask_ = new ::SockAddr6(*from.ifra_prefixmask_);
  } else {
    ifra_prefixmask_ = nullptr;
  }
  if (from._internal_has_ifra_lifetime()) {
    ifra_lifetime_ = new ::In6AddrLifetime_64(*from.ifra_lifetime_);
  } else {
    ifra_lifetime_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:In6_AliasReq_64)
}

void In6_AliasReq_64::SharedCtor() {
ifra_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&ifra_addr_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&ifra_lifetime_) -
    reinterpret_cast<char*>(&ifra_addr_)) + sizeof(ifra_lifetime_));
}

In6_AliasReq_64::~In6_AliasReq_64() {
  // @@protoc_insertion_point(destructor:In6_AliasReq_64)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void In6_AliasReq_64::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ifra_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete ifra_addr_;
  if (this != internal_default_instance()) delete ifra_dstaddr_;
  if (this != internal_default_instance()) delete ifra_prefixmask_;
  if (this != internal_default_instance()) delete ifra_lifetime_;
}

void In6_AliasReq_64::ArenaDtor(void* object) {
  In6_AliasReq_64* _this = reinterpret_cast< In6_AliasReq_64* >(object);
  (void)_this;
}
void In6_AliasReq_64::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void In6_AliasReq_64::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void In6_AliasReq_64::Clear() {
// @@protoc_insertion_point(message_clear_start:In6_AliasReq_64)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ifra_flags_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      ifra_name_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(ifra_addr_ != nullptr);
      ifra_addr_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(ifra_dstaddr_ != nullptr);
      ifra_dstaddr_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(ifra_prefixmask_ != nullptr);
      ifra_prefixmask_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(ifra_lifetime_ != nullptr);
      ifra_lifetime_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* In6_AliasReq_64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required bytes ifra_name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_ifra_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .SockAddr6 ifra_addr = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_ifra_addr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .SockAddr6 ifra_dstaddr = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_ifra_dstaddr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .SockAddr6 ifra_prefixmask = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_ifra_prefixmask(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .IfraFlag ifra_flags = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          ptr -= 1;
          do {
            ptr += 1;
            ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
            if (PROTOBUF_PREDICT_TRUE(::IfraFlag_IsValid(val))) {
              _internal_add_ifra_flags(static_cast<::IfraFlag>(val));
            } else {
              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
            }
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<40>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(_internal_mutable_ifra_flags(), ptr, ctx, ::IfraFlag_IsValid, &_internal_metadata_, 5);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .In6AddrLifetime_64 ifra_lifetime = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_ifra_lifetime(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* In6_AliasReq_64::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:In6_AliasReq_64)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bytes ifra_name = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_ifra_name(), target);
  }

  // required .SockAddr6 ifra_addr = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::ifra_addr(this), target, stream);
  }

  // required .SockAddr6 ifra_dstaddr = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::ifra_dstaddr(this), target, stream);
  }

  // required .SockAddr6 ifra_prefixmask = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::ifra_prefixmask(this), target, stream);
  }

  // repeated .IfraFlag ifra_flags = 5;
  for (int i = 0, n = this->_internal_ifra_flags_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        5, this->_internal_ifra_flags(i), target);
  }

  // required .In6AddrLifetime_64 ifra_lifetime = 6;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::ifra_lifetime(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:In6_AliasReq_64)
  return target;
}

size_t In6_AliasReq_64::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:In6_AliasReq_64)
  size_t total_size = 0;

  if (_internal_has_ifra_name()) {
    // required bytes ifra_name = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_ifra_name());
  }

  if (_internal_has_ifra_addr()) {
    // required .SockAddr6 ifra_addr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ifra_addr_);
  }

  if (_internal_has_ifra_dstaddr()) {
    // required .SockAddr6 ifra_dstaddr = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ifra_dstaddr_);
  }

  if (_internal_has_ifra_prefixmask()) {
    // required .SockAddr6 ifra_prefixmask = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ifra_prefixmask_);
  }

  if (_internal_has_ifra_lifetime()) {
    // required .In6AddrLifetime_64 ifra_lifetime = 6;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ifra_lifetime_);
  }

  return total_size;
}
size_t In6_AliasReq_64::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:In6_AliasReq_64)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x0000001f) ^ 0x0000001f) == 0) {  // All required fields are present.
    // required bytes ifra_name = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_ifra_name());

    // required .SockAddr6 ifra_addr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ifra_addr_);

    // required .SockAddr6 ifra_dstaddr = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ifra_dstaddr_);

    // required .SockAddr6 ifra_prefixmask = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ifra_prefixmask_);

    // required .In6AddrLifetime_64 ifra_lifetime = 6;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ifra_lifetime_);

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .IfraFlag ifra_flags = 5;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->_internal_ifra_flags_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
        this->_internal_ifra_flags(static_cast<int>(i)));
    }
    total_size += (1UL * count) + data_size;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData In6_AliasReq_64::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    In6_AliasReq_64::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*In6_AliasReq_64::GetClassData() const { return &_class_data_; }

void In6_AliasReq_64::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<In6_AliasReq_64 *>(to)->MergeFrom(
      static_cast<const In6_AliasReq_64 &>(from));
}


void In6_AliasReq_64::MergeFrom(const In6_AliasReq_64& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:In6_AliasReq_64)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  ifra_flags_.MergeFrom(from.ifra_flags_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_ifra_name(from._internal_ifra_name());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_ifra_addr()->::SockAddr6::MergeFrom(from._internal_ifra_addr());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_ifra_dstaddr()->::SockAddr6::MergeFrom(from._internal_ifra_dstaddr());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_ifra_prefixmask()->::SockAddr6::MergeFrom(from._internal_ifra_prefixmask());
    }
    if (cached_has_bits & 0x00000010u) {
      _internal_mutable_ifra_lifetime()->::In6AddrLifetime_64::MergeFrom(from._internal_ifra_lifetime());
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void In6_AliasReq_64::CopyFrom(const In6_AliasReq_64& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:In6_AliasReq_64)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool In6_AliasReq_64::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_ifra_addr()) {
    if (!ifra_addr_->IsInitialized()) return false;
  }
  if (_internal_has_ifra_dstaddr()) {
    if (!ifra_dstaddr_->IsInitialized()) return false;
  }
  if (_internal_has_ifra_prefixmask()) {
    if (!ifra_prefixmask_->IsInitialized()) return false;
  }
  if (_internal_has_ifra_lifetime()) {
    if (!ifra_lifetime_->IsInitialized()) return false;
  }
  return true;
}

void In6_AliasReq_64::InternalSwap(In6_AliasReq_64* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ifra_flags_.InternalSwap(&other->ifra_flags_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &ifra_name_, lhs_arena,
      &other->ifra_name_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(In6_AliasReq_64, ifra_lifetime_)
      + sizeof(In6_AliasReq_64::ifra_lifetime_)
      - PROTOBUF_FIELD_OFFSET(In6_AliasReq_64, ifra_addr_)>(
          reinterpret_cast<char*>(&ifra_addr_),
          reinterpret_cast<char*>(&other->ifra_addr_));
}

::PROTOBUF_NAMESPACE_ID::Metadata In6_AliasReq_64::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[41]);
}

// ===================================================================

class In6AddrLifetime_64::_Internal {
 public:
  using HasBits = decltype(std::declval<In6AddrLifetime_64>()._has_bits_);
  static void set_has_ia6t_expire(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_ia6t_preferred(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_ia6t_vltime(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_ia6t_pltime(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000000f) ^ 0x0000000f) != 0;
  }
};

In6AddrLifetime_64::In6AddrLifetime_64(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:In6AddrLifetime_64)
}
In6AddrLifetime_64::In6AddrLifetime_64(const In6AddrLifetime_64& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&ia6t_expire_, &from.ia6t_expire_,
    static_cast<size_t>(reinterpret_cast<char*>(&ia6t_pltime_) -
    reinterpret_cast<char*>(&ia6t_expire_)) + sizeof(ia6t_pltime_));
  // @@protoc_insertion_point(copy_constructor:In6AddrLifetime_64)
}

void In6AddrLifetime_64::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&ia6t_expire_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&ia6t_pltime_) -
    reinterpret_cast<char*>(&ia6t_expire_)) + sizeof(ia6t_pltime_));
}

In6AddrLifetime_64::~In6AddrLifetime_64() {
  // @@protoc_insertion_point(destructor:In6AddrLifetime_64)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void In6AddrLifetime_64::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void In6AddrLifetime_64::ArenaDtor(void* object) {
  In6AddrLifetime_64* _this = reinterpret_cast< In6AddrLifetime_64* >(object);
  (void)_this;
}
void In6AddrLifetime_64::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void In6AddrLifetime_64::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void In6AddrLifetime_64::Clear() {
// @@protoc_insertion_point(message_clear_start:In6AddrLifetime_64)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    ::memset(&ia6t_expire_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&ia6t_pltime_) -
        reinterpret_cast<char*>(&ia6t_expire_)) + sizeof(ia6t_pltime_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* In6AddrLifetime_64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required uint64 ia6t_expire = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ia6t_expire(&has_bits);
          ia6t_expire_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint64 ia6t_preferred = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_ia6t_preferred(&has_bits);
          ia6t_preferred_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ia6t_vltime = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_ia6t_vltime(&has_bits);
          ia6t_vltime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ia6t_pltime = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_ia6t_pltime(&has_bits);
          ia6t_pltime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* In6AddrLifetime_64::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:In6AddrLifetime_64)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 ia6t_expire = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_ia6t_expire(), target);
  }

  // required uint64 ia6t_preferred = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->_internal_ia6t_preferred(), target);
  }

  // required uint32 ia6t_vltime = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_ia6t_vltime(), target);
  }

  // required uint32 ia6t_pltime = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_ia6t_pltime(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:In6AddrLifetime_64)
  return target;
}

size_t In6AddrLifetime_64::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:In6AddrLifetime_64)
  size_t total_size = 0;

  if (_internal_has_ia6t_expire()) {
    // required uint64 ia6t_expire = 1;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_ia6t_expire());
  }

  if (_internal_has_ia6t_preferred()) {
    // required uint64 ia6t_preferred = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_ia6t_preferred());
  }

  if (_internal_has_ia6t_vltime()) {
    // required uint32 ia6t_vltime = 3;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ia6t_vltime());
  }

  if (_internal_has_ia6t_pltime()) {
    // required uint32 ia6t_pltime = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ia6t_pltime());
  }

  return total_size;
}
size_t In6AddrLifetime_64::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:In6AddrLifetime_64)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x0000000f) ^ 0x0000000f) == 0) {  // All required fields are present.
    // required uint64 ia6t_expire = 1;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_ia6t_expire());

    // required uint64 ia6t_preferred = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_ia6t_preferred());

    // required uint32 ia6t_vltime = 3;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ia6t_vltime());

    // required uint32 ia6t_pltime = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ia6t_pltime());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData In6AddrLifetime_64::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    In6AddrLifetime_64::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*In6AddrLifetime_64::GetClassData() const { return &_class_data_; }

void In6AddrLifetime_64::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<In6AddrLifetime_64 *>(to)->MergeFrom(
      static_cast<const In6AddrLifetime_64 &>(from));
}


void In6AddrLifetime_64::MergeFrom(const In6AddrLifetime_64& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:In6AddrLifetime_64)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      ia6t_expire_ = from.ia6t_expire_;
    }
    if (cached_has_bits & 0x00000002u) {
      ia6t_preferred_ = from.ia6t_preferred_;
    }
    if (cached_has_bits & 0x00000004u) {
      ia6t_vltime_ = from.ia6t_vltime_;
    }
    if (cached_has_bits & 0x00000008u) {
      ia6t_pltime_ = from.ia6t_pltime_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void In6AddrLifetime_64::CopyFrom(const In6AddrLifetime_64& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:In6AddrLifetime_64)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool In6AddrLifetime_64::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void In6AddrLifetime_64::InternalSwap(In6AddrLifetime_64* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(In6AddrLifetime_64, ia6t_pltime_)
      + sizeof(In6AddrLifetime_64::ia6t_pltime_)
      - PROTOBUF_FIELD_OFFSET(In6AddrLifetime_64, ia6t_expire_)>(
          reinterpret_cast<char*>(&ia6t_expire_),
          reinterpret_cast<char*>(&other->ia6t_expire_));
}

::PROTOBUF_NAMESPACE_ID::Metadata In6AddrLifetime_64::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[42]);
}

// ===================================================================

class Packet::_Internal {
 public:
  static const ::TcpPacket& tcp_packet(const Packet* msg);
  static const ::Tcp6Packet& tcp6_packet(const Packet* msg);
  static const ::Ip4Packet& ip4_packet(const Packet* msg);
  static const ::Ip6Packet& ip6_packet(const Packet* msg);
};

const ::TcpPacket&
Packet::_Internal::tcp_packet(const Packet* msg) {
  return *msg->packet_.tcp_packet_;
}
const ::Tcp6Packet&
Packet::_Internal::tcp6_packet(const Packet* msg) {
  return *msg->packet_.tcp6_packet_;
}
const ::Ip4Packet&
Packet::_Internal::ip4_packet(const Packet* msg) {
  return *msg->packet_.ip4_packet_;
}
const ::Ip6Packet&
Packet::_Internal::ip6_packet(const Packet* msg) {
  return *msg->packet_.ip6_packet_;
}
void Packet::set_allocated_tcp_packet(::TcpPacket* tcp_packet) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_packet();
  if (tcp_packet) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::TcpPacket>::GetOwningArena(tcp_packet);
    if (message_arena != submessage_arena) {
      tcp_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tcp_packet, submessage_arena);
    }
    set_has_tcp_packet();
    packet_.tcp_packet_ = tcp_packet;
  }
  // @@protoc_insertion_point(field_set_allocated:Packet.tcp_packet)
}
void Packet::set_allocated_tcp6_packet(::Tcp6Packet* tcp6_packet) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_packet();
  if (tcp6_packet) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Tcp6Packet>::GetOwningArena(tcp6_packet);
    if (message_arena != submessage_arena) {
      tcp6_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tcp6_packet, submessage_arena);
    }
    set_has_tcp6_packet();
    packet_.tcp6_packet_ = tcp6_packet;
  }
  // @@protoc_insertion_point(field_set_allocated:Packet.tcp6_packet)
}
void Packet::set_allocated_ip4_packet(::Ip4Packet* ip4_packet) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_packet();
  if (ip4_packet) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Ip4Packet>::GetOwningArena(ip4_packet);
    if (message_arena != submessage_arena) {
      ip4_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ip4_packet, submessage_arena);
    }
    set_has_ip4_packet();
    packet_.ip4_packet_ = ip4_packet;
  }
  // @@protoc_insertion_point(field_set_allocated:Packet.ip4_packet)
}
void Packet::set_allocated_ip6_packet(::Ip6Packet* ip6_packet) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_packet();
  if (ip6_packet) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::Ip6Packet>::GetOwningArena(ip6_packet);
    if (message_arena != submessage_arena) {
      ip6_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ip6_packet, submessage_arena);
    }
    set_has_ip6_packet();
    packet_.ip6_packet_ = ip6_packet;
  }
  // @@protoc_insertion_point(field_set_allocated:Packet.ip6_packet)
}
Packet::Packet(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Packet)
}
Packet::Packet(const Packet& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_packet();
  switch (from.packet_case()) {
    case kTcpPacket: {
      _internal_mutable_tcp_packet()->::TcpPacket::MergeFrom(from._internal_tcp_packet());
      break;
    }
    case kTcp6Packet: {
      _internal_mutable_tcp6_packet()->::Tcp6Packet::MergeFrom(from._internal_tcp6_packet());
      break;
    }
    case kIp4Packet: {
      _internal_mutable_ip4_packet()->::Ip4Packet::MergeFrom(from._internal_ip4_packet());
      break;
    }
    case kIp6Packet: {
      _internal_mutable_ip6_packet()->::Ip6Packet::MergeFrom(from._internal_ip6_packet());
      break;
    }
    case kRawIp4: {
      _internal_set_raw_ip4(from._internal_raw_ip4());
      break;
    }
    case kRawIp6: {
      _internal_set_raw_ip6(from._internal_raw_ip6());
      break;
    }
    case PACKET_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:Packet)
}

void Packet::SharedCtor() {
clear_has_packet();
}

Packet::~Packet() {
  // @@protoc_insertion_point(destructor:Packet)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Packet::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_packet()) {
    clear_packet();
  }
}

void Packet::ArenaDtor(void* object) {
  Packet* _this = reinterpret_cast< Packet* >(object);
  (void)_this;
}
void Packet::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Packet::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Packet::clear_packet() {
// @@protoc_insertion_point(one_of_clear_start:Packet)
  switch (packet_case()) {
    case kTcpPacket: {
      if (GetArenaForAllocation() == nullptr) {
        delete packet_.tcp_packet_;
      }
      break;
    }
    case kTcp6Packet: {
      if (GetArenaForAllocation() == nullptr) {
        delete packet_.tcp6_packet_;
      }
      break;
    }
    case kIp4Packet: {
      if (GetArenaForAllocation() == nullptr) {
        delete packet_.ip4_packet_;
      }
      break;
    }
    case kIp6Packet: {
      if (GetArenaForAllocation() == nullptr) {
        delete packet_.ip6_packet_;
      }
      break;
    }
    case kRawIp4: {
      packet_.raw_ip4_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kRawIp6: {
      packet_.raw_ip6_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case PACKET_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = PACKET_NOT_SET;
}


void Packet::Clear() {
// @@protoc_insertion_point(message_clear_start:Packet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_packet();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Packet::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .TcpPacket tcp_packet = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_tcp_packet(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Tcp6Packet tcp6_packet = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_tcp6_packet(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Ip4Packet ip4_packet = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_ip4_packet(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .Ip6Packet ip6_packet = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_ip6_packet(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bytes raw_ip4 = 1000;
      case 1000:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          auto str = _internal_mutable_raw_ip4();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bytes raw_ip6 = 1001;
      case 1001:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          auto str = _internal_mutable_raw_ip6();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Packet::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Packet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (packet_case()) {
    case kTcpPacket: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::tcp_packet(this), target, stream);
      break;
    }
    case kTcp6Packet: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          2, _Internal::tcp6_packet(this), target, stream);
      break;
    }
    case kIp4Packet: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::ip4_packet(this), target, stream);
      break;
    }
    case kIp6Packet: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          4, _Internal::ip6_packet(this), target, stream);
      break;
    }
    case kRawIp4: {
      target = stream->WriteBytesMaybeAliased(
          1000, this->_internal_raw_ip4(), target);
      break;
    }
    case kRawIp6: {
      target = stream->WriteBytesMaybeAliased(
          1001, this->_internal_raw_ip6(), target);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Packet)
  return target;
}

size_t Packet::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Packet)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (packet_case()) {
    // .TcpPacket tcp_packet = 1;
    case kTcpPacket: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *packet_.tcp_packet_);
      break;
    }
    // .Tcp6Packet tcp6_packet = 2;
    case kTcp6Packet: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *packet_.tcp6_packet_);
      break;
    }
    // .Ip4Packet ip4_packet = 3;
    case kIp4Packet: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *packet_.ip4_packet_);
      break;
    }
    // .Ip6Packet ip6_packet = 4;
    case kIp6Packet: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *packet_.ip6_packet_);
      break;
    }
    // bytes raw_ip4 = 1000;
    case kRawIp4: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_raw_ip4());
      break;
    }
    // bytes raw_ip6 = 1001;
    case kRawIp6: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_raw_ip6());
      break;
    }
    case PACKET_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Packet::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Packet::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Packet::GetClassData() const { return &_class_data_; }

void Packet::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Packet *>(to)->MergeFrom(
      static_cast<const Packet &>(from));
}


void Packet::MergeFrom(const Packet& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Packet)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.packet_case()) {
    case kTcpPacket: {
      _internal_mutable_tcp_packet()->::TcpPacket::MergeFrom(from._internal_tcp_packet());
      break;
    }
    case kTcp6Packet: {
      _internal_mutable_tcp6_packet()->::Tcp6Packet::MergeFrom(from._internal_tcp6_packet());
      break;
    }
    case kIp4Packet: {
      _internal_mutable_ip4_packet()->::Ip4Packet::MergeFrom(from._internal_ip4_packet());
      break;
    }
    case kIp6Packet: {
      _internal_mutable_ip6_packet()->::Ip6Packet::MergeFrom(from._internal_ip6_packet());
      break;
    }
    case kRawIp4: {
      _internal_set_raw_ip4(from._internal_raw_ip4());
      break;
    }
    case kRawIp6: {
      _internal_set_raw_ip6(from._internal_raw_ip6());
      break;
    }
    case PACKET_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Packet::CopyFrom(const Packet& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Packet)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Packet::IsInitialized() const {
  switch (packet_case()) {
    case kTcpPacket: {
      if (has_tcp_packet()) {
        if (!this->tcp_packet().IsInitialized()) return false;
      }
      break;
    }
    case kTcp6Packet: {
      if (has_tcp6_packet()) {
        if (!this->tcp6_packet().IsInitialized()) return false;
      }
      break;
    }
    case kIp4Packet: {
      if (has_ip4_packet()) {
        if (!this->ip4_packet().IsInitialized()) return false;
      }
      break;
    }
    case kIp6Packet: {
      if (has_ip6_packet()) {
        if (!this->ip6_packet().IsInitialized()) return false;
      }
      break;
    }
    case kRawIp4: {
      break;
    }
    case kRawIp6: {
      break;
    }
    case PACKET_NOT_SET: {
      break;
    }
  }
  return true;
}

void Packet::InternalSwap(Packet* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(packet_, other->packet_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata Packet::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[43]);
}

// ===================================================================

class TcpPacket::_Internal {
 public:
  using HasBits = decltype(std::declval<TcpPacket>()._has_bits_);
  static const ::IpHdr& ip_hdr(const TcpPacket* msg);
  static void set_has_ip_hdr(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::TcpHdr& tcp_hdr(const TcpPacket* msg);
  static void set_has_tcp_hdr(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000006) ^ 0x00000006) != 0;
  }
};

const ::IpHdr&
TcpPacket::_Internal::ip_hdr(const TcpPacket* msg) {
  return *msg->ip_hdr_;
}
const ::TcpHdr&
TcpPacket::_Internal::tcp_hdr(const TcpPacket* msg) {
  return *msg->tcp_hdr_;
}
TcpPacket::TcpPacket(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:TcpPacket)
}
TcpPacket::TcpPacket(const TcpPacket& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data()) {
    data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_ip_hdr()) {
    ip_hdr_ = new ::IpHdr(*from.ip_hdr_);
  } else {
    ip_hdr_ = nullptr;
  }
  if (from._internal_has_tcp_hdr()) {
    tcp_hdr_ = new ::TcpHdr(*from.tcp_hdr_);
  } else {
    tcp_hdr_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:TcpPacket)
}

void TcpPacket::SharedCtor() {
data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&ip_hdr_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&tcp_hdr_) -
    reinterpret_cast<char*>(&ip_hdr_)) + sizeof(tcp_hdr_));
}

TcpPacket::~TcpPacket() {
  // @@protoc_insertion_point(destructor:TcpPacket)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void TcpPacket::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete ip_hdr_;
  if (this != internal_default_instance()) delete tcp_hdr_;
}

void TcpPacket::ArenaDtor(void* object) {
  TcpPacket* _this = reinterpret_cast< TcpPacket* >(object);
  (void)_this;
}
void TcpPacket::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void TcpPacket::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void TcpPacket::Clear() {
// @@protoc_insertion_point(message_clear_start:TcpPacket)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      data_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(ip_hdr_ != nullptr);
      ip_hdr_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(tcp_hdr_ != nullptr);
      tcp_hdr_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* TcpPacket::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .IpHdr ip_hdr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_ip_hdr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .TcpHdr tcp_hdr = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_tcp_hdr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bytes data = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* TcpPacket::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:TcpPacket)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .IpHdr ip_hdr = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::ip_hdr(this), target, stream);
  }

  // required .TcpHdr tcp_hdr = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::tcp_hdr(this), target, stream);
  }

  // optional bytes data = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        3, this->_internal_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:TcpPacket)
  return target;
}

size_t TcpPacket::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:TcpPacket)
  size_t total_size = 0;

  if (_internal_has_ip_hdr()) {
    // required .IpHdr ip_hdr = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ip_hdr_);
  }

  if (_internal_has_tcp_hdr()) {
    // required .TcpHdr tcp_hdr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *tcp_hdr_);
  }

  return total_size;
}
size_t TcpPacket::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:TcpPacket)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000006) ^ 0x00000006) == 0) {  // All required fields are present.
    // required .IpHdr ip_hdr = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ip_hdr_);

    // required .TcpHdr tcp_hdr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *tcp_hdr_);

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bytes data = 3;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_data());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TcpPacket::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    TcpPacket::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TcpPacket::GetClassData() const { return &_class_data_; }

void TcpPacket::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<TcpPacket *>(to)->MergeFrom(
      static_cast<const TcpPacket &>(from));
}


void TcpPacket::MergeFrom(const TcpPacket& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:TcpPacket)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_data(from._internal_data());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_ip_hdr()->::IpHdr::MergeFrom(from._internal_ip_hdr());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_tcp_hdr()->::TcpHdr::MergeFrom(from._internal_tcp_hdr());
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void TcpPacket::CopyFrom(const TcpPacket& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:TcpPacket)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TcpPacket::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_ip_hdr()) {
    if (!ip_hdr_->IsInitialized()) return false;
  }
  if (_internal_has_tcp_hdr()) {
    if (!tcp_hdr_->IsInitialized()) return false;
  }
  return true;
}

void TcpPacket::InternalSwap(TcpPacket* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &data_, lhs_arena,
      &other->data_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(TcpPacket, tcp_hdr_)
      + sizeof(TcpPacket::tcp_hdr_)
      - PROTOBUF_FIELD_OFFSET(TcpPacket, ip_hdr_)>(
          reinterpret_cast<char*>(&ip_hdr_),
          reinterpret_cast<char*>(&other->ip_hdr_));
}

::PROTOBUF_NAMESPACE_ID::Metadata TcpPacket::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[44]);
}

// ===================================================================

class Tcp6Packet::_Internal {
 public:
  using HasBits = decltype(std::declval<Tcp6Packet>()._has_bits_);
  static const ::Ip6Hdr& ip6_hdr(const Tcp6Packet* msg);
  static void set_has_ip6_hdr(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::TcpHdr& tcp_hdr(const Tcp6Packet* msg);
  static void set_has_tcp_hdr(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000006) ^ 0x00000006) != 0;
  }
};

const ::Ip6Hdr&
Tcp6Packet::_Internal::ip6_hdr(const Tcp6Packet* msg) {
  return *msg->ip6_hdr_;
}
const ::TcpHdr&
Tcp6Packet::_Internal::tcp_hdr(const Tcp6Packet* msg) {
  return *msg->tcp_hdr_;
}
Tcp6Packet::Tcp6Packet(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Tcp6Packet)
}
Tcp6Packet::Tcp6Packet(const Tcp6Packet& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data()) {
    data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_ip6_hdr()) {
    ip6_hdr_ = new ::Ip6Hdr(*from.ip6_hdr_);
  } else {
    ip6_hdr_ = nullptr;
  }
  if (from._internal_has_tcp_hdr()) {
    tcp_hdr_ = new ::TcpHdr(*from.tcp_hdr_);
  } else {
    tcp_hdr_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:Tcp6Packet)
}

void Tcp6Packet::SharedCtor() {
data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&ip6_hdr_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&tcp_hdr_) -
    reinterpret_cast<char*>(&ip6_hdr_)) + sizeof(tcp_hdr_));
}

Tcp6Packet::~Tcp6Packet() {
  // @@protoc_insertion_point(destructor:Tcp6Packet)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Tcp6Packet::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete ip6_hdr_;
  if (this != internal_default_instance()) delete tcp_hdr_;
}

void Tcp6Packet::ArenaDtor(void* object) {
  Tcp6Packet* _this = reinterpret_cast< Tcp6Packet* >(object);
  (void)_this;
}
void Tcp6Packet::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Tcp6Packet::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Tcp6Packet::Clear() {
// @@protoc_insertion_point(message_clear_start:Tcp6Packet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      data_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(ip6_hdr_ != nullptr);
      ip6_hdr_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(tcp_hdr_ != nullptr);
      tcp_hdr_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Tcp6Packet::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .Ip6Hdr ip6_hdr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_ip6_hdr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .TcpHdr tcp_hdr = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_tcp_hdr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bytes data = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Tcp6Packet::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Tcp6Packet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .Ip6Hdr ip6_hdr = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::ip6_hdr(this), target, stream);
  }

  // required .TcpHdr tcp_hdr = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::tcp_hdr(this), target, stream);
  }

  // optional bytes data = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        3, this->_internal_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Tcp6Packet)
  return target;
}

size_t Tcp6Packet::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Tcp6Packet)
  size_t total_size = 0;

  if (_internal_has_ip6_hdr()) {
    // required .Ip6Hdr ip6_hdr = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ip6_hdr_);
  }

  if (_internal_has_tcp_hdr()) {
    // required .TcpHdr tcp_hdr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *tcp_hdr_);
  }

  return total_size;
}
size_t Tcp6Packet::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Tcp6Packet)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000006) ^ 0x00000006) == 0) {  // All required fields are present.
    // required .Ip6Hdr ip6_hdr = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ip6_hdr_);

    // required .TcpHdr tcp_hdr = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *tcp_hdr_);

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bytes data = 3;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_data());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Tcp6Packet::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Tcp6Packet::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Tcp6Packet::GetClassData() const { return &_class_data_; }

void Tcp6Packet::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Tcp6Packet *>(to)->MergeFrom(
      static_cast<const Tcp6Packet &>(from));
}


void Tcp6Packet::MergeFrom(const Tcp6Packet& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Tcp6Packet)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_data(from._internal_data());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_ip6_hdr()->::Ip6Hdr::MergeFrom(from._internal_ip6_hdr());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_tcp_hdr()->::TcpHdr::MergeFrom(from._internal_tcp_hdr());
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Tcp6Packet::CopyFrom(const Tcp6Packet& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Tcp6Packet)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Tcp6Packet::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_ip6_hdr()) {
    if (!ip6_hdr_->IsInitialized()) return false;
  }
  if (_internal_has_tcp_hdr()) {
    if (!tcp_hdr_->IsInitialized()) return false;
  }
  return true;
}

void Tcp6Packet::InternalSwap(Tcp6Packet* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &data_, lhs_arena,
      &other->data_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Tcp6Packet, tcp_hdr_)
      + sizeof(Tcp6Packet::tcp_hdr_)
      - PROTOBUF_FIELD_OFFSET(Tcp6Packet, ip6_hdr_)>(
          reinterpret_cast<char*>(&ip6_hdr_),
          reinterpret_cast<char*>(&other->ip6_hdr_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Tcp6Packet::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[45]);
}

// ===================================================================

class Ip4Packet::_Internal {
 public:
  using HasBits = decltype(std::declval<Ip4Packet>()._has_bits_);
  static const ::IpHdr& ip_hdr(const Ip4Packet* msg);
  static void set_has_ip_hdr(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::IpHdr&
Ip4Packet::_Internal::ip_hdr(const Ip4Packet* msg) {
  return *msg->ip_hdr_;
}
Ip4Packet::Ip4Packet(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Ip4Packet)
}
Ip4Packet::Ip4Packet(const Ip4Packet& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data()) {
    data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_ip_hdr()) {
    ip_hdr_ = new ::IpHdr(*from.ip_hdr_);
  } else {
    ip_hdr_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:Ip4Packet)
}

void Ip4Packet::SharedCtor() {
data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
ip_hdr_ = nullptr;
}

Ip4Packet::~Ip4Packet() {
  // @@protoc_insertion_point(destructor:Ip4Packet)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Ip4Packet::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete ip_hdr_;
}

void Ip4Packet::ArenaDtor(void* object) {
  Ip4Packet* _this = reinterpret_cast< Ip4Packet* >(object);
  (void)_this;
}
void Ip4Packet::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Ip4Packet::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Ip4Packet::Clear() {
// @@protoc_insertion_point(message_clear_start:Ip4Packet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      data_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(ip_hdr_ != nullptr);
      ip_hdr_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Ip4Packet::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .IpHdr ip_hdr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_ip_hdr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bytes data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Ip4Packet::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Ip4Packet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .IpHdr ip_hdr = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::ip_hdr(this), target, stream);
  }

  // optional bytes data = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Ip4Packet)
  return target;
}

size_t Ip4Packet::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Ip4Packet)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional bytes data = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_data());
    }

    // optional .IpHdr ip_hdr = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *ip_hdr_);
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Ip4Packet::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Ip4Packet::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Ip4Packet::GetClassData() const { return &_class_data_; }

void Ip4Packet::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Ip4Packet *>(to)->MergeFrom(
      static_cast<const Ip4Packet &>(from));
}


void Ip4Packet::MergeFrom(const Ip4Packet& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Ip4Packet)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_data(from._internal_data());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_ip_hdr()->::IpHdr::MergeFrom(from._internal_ip_hdr());
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Ip4Packet::CopyFrom(const Ip4Packet& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Ip4Packet)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Ip4Packet::IsInitialized() const {
  if (_internal_has_ip_hdr()) {
    if (!ip_hdr_->IsInitialized()) return false;
  }
  return true;
}

void Ip4Packet::InternalSwap(Ip4Packet* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &data_, lhs_arena,
      &other->data_, rhs_arena
  );
  swap(ip_hdr_, other->ip_hdr_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Ip4Packet::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[46]);
}

// ===================================================================

class Ip6Packet::_Internal {
 public:
  using HasBits = decltype(std::declval<Ip6Packet>()._has_bits_);
  static const ::Ip6Hdr& ip6_hdr(const Ip6Packet* msg);
  static void set_has_ip6_hdr(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::Ip6Hdr&
Ip6Packet::_Internal::ip6_hdr(const Ip6Packet* msg) {
  return *msg->ip6_hdr_;
}
Ip6Packet::Ip6Packet(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Ip6Packet)
}
Ip6Packet::Ip6Packet(const Ip6Packet& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data()) {
    data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_ip6_hdr()) {
    ip6_hdr_ = new ::Ip6Hdr(*from.ip6_hdr_);
  } else {
    ip6_hdr_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:Ip6Packet)
}

void Ip6Packet::SharedCtor() {
data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
ip6_hdr_ = nullptr;
}

Ip6Packet::~Ip6Packet() {
  // @@protoc_insertion_point(destructor:Ip6Packet)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Ip6Packet::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete ip6_hdr_;
}

void Ip6Packet::ArenaDtor(void* object) {
  Ip6Packet* _this = reinterpret_cast< Ip6Packet* >(object);
  (void)_this;
}
void Ip6Packet::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Ip6Packet::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Ip6Packet::Clear() {
// @@protoc_insertion_point(message_clear_start:Ip6Packet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      data_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(ip6_hdr_ != nullptr);
      ip6_hdr_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Ip6Packet::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .Ip6Hdr ip6_hdr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_ip6_hdr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bytes data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Ip6Packet::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Ip6Packet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .Ip6Hdr ip6_hdr = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::ip6_hdr(this), target, stream);
  }

  // optional bytes data = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Ip6Packet)
  return target;
}

size_t Ip6Packet::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Ip6Packet)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional bytes data = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_data());
    }

    // optional .Ip6Hdr ip6_hdr = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *ip6_hdr_);
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Ip6Packet::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Ip6Packet::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Ip6Packet::GetClassData() const { return &_class_data_; }

void Ip6Packet::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Ip6Packet *>(to)->MergeFrom(
      static_cast<const Ip6Packet &>(from));
}


void Ip6Packet::MergeFrom(const Ip6Packet& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Ip6Packet)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_data(from._internal_data());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_ip6_hdr()->::Ip6Hdr::MergeFrom(from._internal_ip6_hdr());
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Ip6Packet::CopyFrom(const Ip6Packet& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Ip6Packet)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Ip6Packet::IsInitialized() const {
  if (_internal_has_ip6_hdr()) {
    if (!ip6_hdr_->IsInitialized()) return false;
  }
  return true;
}

void Ip6Packet::InternalSwap(Ip6Packet* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &data_, lhs_arena,
      &other->data_, rhs_arena
  );
  swap(ip6_hdr_, other->ip6_hdr_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Ip6Packet::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[47]);
}

// ===================================================================

class Ip6Ext::_Internal {
 public:
  using HasBits = decltype(std::declval<Ip6Ext>()._has_bits_);
  static void set_has_ip6e_nxt(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_ip6e_len(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

Ip6Ext::Ip6Ext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Ip6Ext)
}
Ip6Ext::Ip6Ext(const Ip6Ext& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&ip6e_nxt_, &from.ip6e_nxt_,
    static_cast<size_t>(reinterpret_cast<char*>(&ip6e_len_) -
    reinterpret_cast<char*>(&ip6e_nxt_)) + sizeof(ip6e_len_));
  // @@protoc_insertion_point(copy_constructor:Ip6Ext)
}

void Ip6Ext::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&ip6e_nxt_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&ip6e_len_) -
    reinterpret_cast<char*>(&ip6e_nxt_)) + sizeof(ip6e_len_));
}

Ip6Ext::~Ip6Ext() {
  // @@protoc_insertion_point(destructor:Ip6Ext)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Ip6Ext::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Ip6Ext::ArenaDtor(void* object) {
  Ip6Ext* _this = reinterpret_cast< Ip6Ext* >(object);
  (void)_this;
}
void Ip6Ext::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Ip6Ext::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Ip6Ext::Clear() {
// @@protoc_insertion_point(message_clear_start:Ip6Ext)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&ip6e_nxt_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&ip6e_len_) -
        reinterpret_cast<char*>(&ip6e_nxt_)) + sizeof(ip6e_len_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Ip6Ext::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .Protocol ip6e_nxt = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Protocol_IsValid(val))) {
            _internal_set_ip6e_nxt(static_cast<::Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6e_len = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_ip6e_len(&has_bits);
          ip6e_len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Ip6Ext::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Ip6Ext)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .Protocol ip6e_nxt = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_ip6e_nxt(), target);
  }

  // required uint32 ip6e_len = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_ip6e_len(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Ip6Ext)
  return target;
}

size_t Ip6Ext::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Ip6Ext)
  size_t total_size = 0;

  if (_internal_has_ip6e_nxt()) {
    // required .Protocol ip6e_nxt = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6e_nxt());
  }

  if (_internal_has_ip6e_len()) {
    // required uint32 ip6e_len = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6e_len());
  }

  return total_size;
}
size_t Ip6Ext::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Ip6Ext)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required .Protocol ip6e_nxt = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6e_nxt());

    // required uint32 ip6e_len = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6e_len());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Ip6Ext::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Ip6Ext::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Ip6Ext::GetClassData() const { return &_class_data_; }

void Ip6Ext::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Ip6Ext *>(to)->MergeFrom(
      static_cast<const Ip6Ext &>(from));
}


void Ip6Ext::MergeFrom(const Ip6Ext& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Ip6Ext)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ip6e_nxt_ = from.ip6e_nxt_;
    }
    if (cached_has_bits & 0x00000002u) {
      ip6e_len_ = from.ip6e_len_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Ip6Ext::CopyFrom(const Ip6Ext& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Ip6Ext)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Ip6Ext::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void Ip6Ext::InternalSwap(Ip6Ext* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Ip6Ext, ip6e_len_)
      + sizeof(Ip6Ext::ip6e_len_)
      - PROTOBUF_FIELD_OFFSET(Ip6Ext, ip6e_nxt_)>(
          reinterpret_cast<char*>(&ip6e_nxt_),
          reinterpret_cast<char*>(&other->ip6e_nxt_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Ip6Ext::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[48]);
}

// ===================================================================

class Ip6RtHdr::_Internal {
 public:
  using HasBits = decltype(std::declval<Ip6RtHdr>()._has_bits_);
  static void set_has_ip6r_nxt(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_ip6r_len(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_ip6r_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_ip6r_segleft(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000000f) ^ 0x0000000f) != 0;
  }
};

Ip6RtHdr::Ip6RtHdr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Ip6RtHdr)
}
Ip6RtHdr::Ip6RtHdr(const Ip6RtHdr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&ip6r_nxt_, &from.ip6r_nxt_,
    static_cast<size_t>(reinterpret_cast<char*>(&ip6r_segleft_) -
    reinterpret_cast<char*>(&ip6r_nxt_)) + sizeof(ip6r_segleft_));
  // @@protoc_insertion_point(copy_constructor:Ip6RtHdr)
}

void Ip6RtHdr::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&ip6r_nxt_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&ip6r_segleft_) -
    reinterpret_cast<char*>(&ip6r_nxt_)) + sizeof(ip6r_segleft_));
}

Ip6RtHdr::~Ip6RtHdr() {
  // @@protoc_insertion_point(destructor:Ip6RtHdr)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Ip6RtHdr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Ip6RtHdr::ArenaDtor(void* object) {
  Ip6RtHdr* _this = reinterpret_cast< Ip6RtHdr* >(object);
  (void)_this;
}
void Ip6RtHdr::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Ip6RtHdr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Ip6RtHdr::Clear() {
// @@protoc_insertion_point(message_clear_start:Ip6RtHdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    ::memset(&ip6r_nxt_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&ip6r_segleft_) -
        reinterpret_cast<char*>(&ip6r_nxt_)) + sizeof(ip6r_segleft_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Ip6RtHdr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .Protocol ip6r_nxt = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Protocol_IsValid(val))) {
            _internal_set_ip6r_nxt(static_cast<::Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6r_len = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_ip6r_len(&has_bits);
          ip6r_len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .Ip6RtType ip6r_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Ip6RtType_IsValid(val))) {
            _internal_set_ip6r_type(static_cast<::Ip6RtType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6r_segleft = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_ip6r_segleft(&has_bits);
          ip6r_segleft_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Ip6RtHdr::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Ip6RtHdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .Protocol ip6r_nxt = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_ip6r_nxt(), target);
  }

  // required uint32 ip6r_len = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_ip6r_len(), target);
  }

  // required .Ip6RtType ip6r_type = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_ip6r_type(), target);
  }

  // required uint32 ip6r_segleft = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_ip6r_segleft(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Ip6RtHdr)
  return target;
}

size_t Ip6RtHdr::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Ip6RtHdr)
  size_t total_size = 0;

  if (_internal_has_ip6r_nxt()) {
    // required .Protocol ip6r_nxt = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6r_nxt());
  }

  if (_internal_has_ip6r_len()) {
    // required uint32 ip6r_len = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r_len());
  }

  if (_internal_has_ip6r_type()) {
    // required .Ip6RtType ip6r_type = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6r_type());
  }

  if (_internal_has_ip6r_segleft()) {
    // required uint32 ip6r_segleft = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r_segleft());
  }

  return total_size;
}
size_t Ip6RtHdr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Ip6RtHdr)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x0000000f) ^ 0x0000000f) == 0) {  // All required fields are present.
    // required .Protocol ip6r_nxt = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6r_nxt());

    // required uint32 ip6r_len = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r_len());

    // required .Ip6RtType ip6r_type = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6r_type());

    // required uint32 ip6r_segleft = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r_segleft());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Ip6RtHdr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Ip6RtHdr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Ip6RtHdr::GetClassData() const { return &_class_data_; }

void Ip6RtHdr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Ip6RtHdr *>(to)->MergeFrom(
      static_cast<const Ip6RtHdr &>(from));
}


void Ip6RtHdr::MergeFrom(const Ip6RtHdr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Ip6RtHdr)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      ip6r_nxt_ = from.ip6r_nxt_;
    }
    if (cached_has_bits & 0x00000002u) {
      ip6r_len_ = from.ip6r_len_;
    }
    if (cached_has_bits & 0x00000004u) {
      ip6r_type_ = from.ip6r_type_;
    }
    if (cached_has_bits & 0x00000008u) {
      ip6r_segleft_ = from.ip6r_segleft_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Ip6RtHdr::CopyFrom(const Ip6RtHdr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Ip6RtHdr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Ip6RtHdr::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void Ip6RtHdr::InternalSwap(Ip6RtHdr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Ip6RtHdr, ip6r_segleft_)
      + sizeof(Ip6RtHdr::ip6r_segleft_)
      - PROTOBUF_FIELD_OFFSET(Ip6RtHdr, ip6r_nxt_)>(
          reinterpret_cast<char*>(&ip6r_nxt_),
          reinterpret_cast<char*>(&other->ip6r_nxt_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Ip6RtHdr::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[49]);
}

// ===================================================================

class Ip6Rt0Hdr::_Internal {
 public:
  using HasBits = decltype(std::declval<Ip6Rt0Hdr>()._has_bits_);
  static void set_has_ip6r0_nxt(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_ip6r0_len(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_ip6r0_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_ip6r0_segleft(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_ip6r0_reserved(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_ip6r0_slmap(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000003f) ^ 0x0000003f) != 0;
  }
};

Ip6Rt0Hdr::Ip6Rt0Hdr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  ip6r0_addr_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Ip6Rt0Hdr)
}
Ip6Rt0Hdr::Ip6Rt0Hdr(const Ip6Rt0Hdr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      ip6r0_addr_(from.ip6r0_addr_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&ip6r0_nxt_, &from.ip6r0_nxt_,
    static_cast<size_t>(reinterpret_cast<char*>(&ip6r0_slmap_) -
    reinterpret_cast<char*>(&ip6r0_nxt_)) + sizeof(ip6r0_slmap_));
  // @@protoc_insertion_point(copy_constructor:Ip6Rt0Hdr)
}

void Ip6Rt0Hdr::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&ip6r0_nxt_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&ip6r0_slmap_) -
    reinterpret_cast<char*>(&ip6r0_nxt_)) + sizeof(ip6r0_slmap_));
}

Ip6Rt0Hdr::~Ip6Rt0Hdr() {
  // @@protoc_insertion_point(destructor:Ip6Rt0Hdr)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Ip6Rt0Hdr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Ip6Rt0Hdr::ArenaDtor(void* object) {
  Ip6Rt0Hdr* _this = reinterpret_cast< Ip6Rt0Hdr* >(object);
  (void)_this;
}
void Ip6Rt0Hdr::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Ip6Rt0Hdr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Ip6Rt0Hdr::Clear() {
// @@protoc_insertion_point(message_clear_start:Ip6Rt0Hdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ip6r0_addr_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    ::memset(&ip6r0_nxt_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&ip6r0_slmap_) -
        reinterpret_cast<char*>(&ip6r0_nxt_)) + sizeof(ip6r0_slmap_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Ip6Rt0Hdr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .Protocol ip6r0_nxt = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Protocol_IsValid(val))) {
            _internal_set_ip6r0_nxt(static_cast<::Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6r0_len = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_ip6r0_len(&has_bits);
          ip6r0_len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6r0_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_ip6r0_type(&has_bits);
          ip6r0_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6r0_segleft = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_ip6r0_segleft(&has_bits);
          ip6r0_segleft_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6r0_reserved = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_ip6r0_reserved(&has_bits);
          ip6r0_reserved_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6r0_slmap = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_ip6r0_slmap(&has_bits);
          ip6r0_slmap_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .In6Addr ip6r0_addr = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          ptr -= 1;
          do {
            ptr += 1;
            ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
            if (PROTOBUF_PREDICT_TRUE(::In6Addr_IsValid(val))) {
              _internal_add_ip6r0_addr(static_cast<::In6Addr>(val));
            } else {
              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(7, val, mutable_unknown_fields());
            }
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<56>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(_internal_mutable_ip6r0_addr(), ptr, ctx, ::In6Addr_IsValid, &_internal_metadata_, 7);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Ip6Rt0Hdr::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Ip6Rt0Hdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .Protocol ip6r0_nxt = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_ip6r0_nxt(), target);
  }

  // required uint32 ip6r0_len = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_ip6r0_len(), target);
  }

  // required uint32 ip6r0_type = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_ip6r0_type(), target);
  }

  // required uint32 ip6r0_segleft = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_ip6r0_segleft(), target);
  }

  // required uint32 ip6r0_reserved = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_ip6r0_reserved(), target);
  }

  // required uint32 ip6r0_slmap = 6;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_ip6r0_slmap(), target);
  }

  // repeated .In6Addr ip6r0_addr = 7;
  for (int i = 0, n = this->_internal_ip6r0_addr_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        7, this->_internal_ip6r0_addr(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Ip6Rt0Hdr)
  return target;
}

size_t Ip6Rt0Hdr::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Ip6Rt0Hdr)
  size_t total_size = 0;

  if (_internal_has_ip6r0_nxt()) {
    // required .Protocol ip6r0_nxt = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6r0_nxt());
  }

  if (_internal_has_ip6r0_len()) {
    // required uint32 ip6r0_len = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r0_len());
  }

  if (_internal_has_ip6r0_type()) {
    // required uint32 ip6r0_type = 3;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r0_type());
  }

  if (_internal_has_ip6r0_segleft()) {
    // required uint32 ip6r0_segleft = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r0_segleft());
  }

  if (_internal_has_ip6r0_reserved()) {
    // required uint32 ip6r0_reserved = 5;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r0_reserved());
  }

  if (_internal_has_ip6r0_slmap()) {
    // required uint32 ip6r0_slmap = 6;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r0_slmap());
  }

  return total_size;
}
size_t Ip6Rt0Hdr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Ip6Rt0Hdr)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x0000003f) ^ 0x0000003f) == 0) {  // All required fields are present.
    // required .Protocol ip6r0_nxt = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6r0_nxt());

    // required uint32 ip6r0_len = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r0_len());

    // required uint32 ip6r0_type = 3;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r0_type());

    // required uint32 ip6r0_segleft = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r0_segleft());

    // required uint32 ip6r0_reserved = 5;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r0_reserved());

    // required uint32 ip6r0_slmap = 6;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6r0_slmap());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .In6Addr ip6r0_addr = 7;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->_internal_ip6r0_addr_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
        this->_internal_ip6r0_addr(static_cast<int>(i)));
    }
    total_size += (1UL * count) + data_size;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Ip6Rt0Hdr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Ip6Rt0Hdr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Ip6Rt0Hdr::GetClassData() const { return &_class_data_; }

void Ip6Rt0Hdr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Ip6Rt0Hdr *>(to)->MergeFrom(
      static_cast<const Ip6Rt0Hdr &>(from));
}


void Ip6Rt0Hdr::MergeFrom(const Ip6Rt0Hdr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Ip6Rt0Hdr)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  ip6r0_addr_.MergeFrom(from.ip6r0_addr_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      ip6r0_nxt_ = from.ip6r0_nxt_;
    }
    if (cached_has_bits & 0x00000002u) {
      ip6r0_len_ = from.ip6r0_len_;
    }
    if (cached_has_bits & 0x00000004u) {
      ip6r0_type_ = from.ip6r0_type_;
    }
    if (cached_has_bits & 0x00000008u) {
      ip6r0_segleft_ = from.ip6r0_segleft_;
    }
    if (cached_has_bits & 0x00000010u) {
      ip6r0_reserved_ = from.ip6r0_reserved_;
    }
    if (cached_has_bits & 0x00000020u) {
      ip6r0_slmap_ = from.ip6r0_slmap_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Ip6Rt0Hdr::CopyFrom(const Ip6Rt0Hdr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Ip6Rt0Hdr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Ip6Rt0Hdr::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void Ip6Rt0Hdr::InternalSwap(Ip6Rt0Hdr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ip6r0_addr_.InternalSwap(&other->ip6r0_addr_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Ip6Rt0Hdr, ip6r0_slmap_)
      + sizeof(Ip6Rt0Hdr::ip6r0_slmap_)
      - PROTOBUF_FIELD_OFFSET(Ip6Rt0Hdr, ip6r0_nxt_)>(
          reinterpret_cast<char*>(&ip6r0_nxt_),
          reinterpret_cast<char*>(&other->ip6r0_nxt_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Ip6Rt0Hdr::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[50]);
}

// ===================================================================

class Ip6FragHdr::_Internal {
 public:
  using HasBits = decltype(std::declval<Ip6FragHdr>()._has_bits_);
  static void set_has_ip6f_nxt(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_ip6f_reserved(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_ip6f_offlg(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_ip6f_ident(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000000f) ^ 0x0000000f) != 0;
  }
};

Ip6FragHdr::Ip6FragHdr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Ip6FragHdr)
}
Ip6FragHdr::Ip6FragHdr(const Ip6FragHdr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&ip6f_nxt_, &from.ip6f_nxt_,
    static_cast<size_t>(reinterpret_cast<char*>(&ip6f_ident_) -
    reinterpret_cast<char*>(&ip6f_nxt_)) + sizeof(ip6f_ident_));
  // @@protoc_insertion_point(copy_constructor:Ip6FragHdr)
}

void Ip6FragHdr::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&ip6f_nxt_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&ip6f_ident_) -
    reinterpret_cast<char*>(&ip6f_nxt_)) + sizeof(ip6f_ident_));
}

Ip6FragHdr::~Ip6FragHdr() {
  // @@protoc_insertion_point(destructor:Ip6FragHdr)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Ip6FragHdr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Ip6FragHdr::ArenaDtor(void* object) {
  Ip6FragHdr* _this = reinterpret_cast< Ip6FragHdr* >(object);
  (void)_this;
}
void Ip6FragHdr::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Ip6FragHdr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Ip6FragHdr::Clear() {
// @@protoc_insertion_point(message_clear_start:Ip6FragHdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    ::memset(&ip6f_nxt_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&ip6f_ident_) -
        reinterpret_cast<char*>(&ip6f_nxt_)) + sizeof(ip6f_ident_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Ip6FragHdr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .Protocol ip6f_nxt = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Protocol_IsValid(val))) {
            _internal_set_ip6f_nxt(static_cast<::Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6f_reserved = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_ip6f_reserved(&has_bits);
          ip6f_reserved_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6f_offlg = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_ip6f_offlg(&has_bits);
          ip6f_offlg_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6f_ident = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_ip6f_ident(&has_bits);
          ip6f_ident_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Ip6FragHdr::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Ip6FragHdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .Protocol ip6f_nxt = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_ip6f_nxt(), target);
  }

  // required uint32 ip6f_reserved = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_ip6f_reserved(), target);
  }

  // required uint32 ip6f_offlg = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_ip6f_offlg(), target);
  }

  // required uint32 ip6f_ident = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_ip6f_ident(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Ip6FragHdr)
  return target;
}

size_t Ip6FragHdr::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Ip6FragHdr)
  size_t total_size = 0;

  if (_internal_has_ip6f_nxt()) {
    // required .Protocol ip6f_nxt = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6f_nxt());
  }

  if (_internal_has_ip6f_reserved()) {
    // required uint32 ip6f_reserved = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6f_reserved());
  }

  if (_internal_has_ip6f_offlg()) {
    // required uint32 ip6f_offlg = 3;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6f_offlg());
  }

  if (_internal_has_ip6f_ident()) {
    // required uint32 ip6f_ident = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6f_ident());
  }

  return total_size;
}
size_t Ip6FragHdr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Ip6FragHdr)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x0000000f) ^ 0x0000000f) == 0) {  // All required fields are present.
    // required .Protocol ip6f_nxt = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6f_nxt());

    // required uint32 ip6f_reserved = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6f_reserved());

    // required uint32 ip6f_offlg = 3;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6f_offlg());

    // required uint32 ip6f_ident = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6f_ident());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Ip6FragHdr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Ip6FragHdr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Ip6FragHdr::GetClassData() const { return &_class_data_; }

void Ip6FragHdr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Ip6FragHdr *>(to)->MergeFrom(
      static_cast<const Ip6FragHdr &>(from));
}


void Ip6FragHdr::MergeFrom(const Ip6FragHdr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Ip6FragHdr)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      ip6f_nxt_ = from.ip6f_nxt_;
    }
    if (cached_has_bits & 0x00000002u) {
      ip6f_reserved_ = from.ip6f_reserved_;
    }
    if (cached_has_bits & 0x00000004u) {
      ip6f_offlg_ = from.ip6f_offlg_;
    }
    if (cached_has_bits & 0x00000008u) {
      ip6f_ident_ = from.ip6f_ident_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Ip6FragHdr::CopyFrom(const Ip6FragHdr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Ip6FragHdr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Ip6FragHdr::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void Ip6FragHdr::InternalSwap(Ip6FragHdr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Ip6FragHdr, ip6f_ident_)
      + sizeof(Ip6FragHdr::ip6f_ident_)
      - PROTOBUF_FIELD_OFFSET(Ip6FragHdr, ip6f_nxt_)>(
          reinterpret_cast<char*>(&ip6f_nxt_),
          reinterpret_cast<char*>(&other->ip6f_nxt_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Ip6FragHdr::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[51]);
}

// ===================================================================

class Icmp6Hdr::_Internal {
 public:
  using HasBits = decltype(std::declval<Icmp6Hdr>()._has_bits_);
  static void set_has_icmp6_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_icmp6_code(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_icmp6_dataun(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

Icmp6Hdr::Icmp6Hdr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Icmp6Hdr)
}
Icmp6Hdr::Icmp6Hdr(const Icmp6Hdr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&icmp6_code_, &from.icmp6_code_,
    static_cast<size_t>(reinterpret_cast<char*>(&icmp6_type_) -
    reinterpret_cast<char*>(&icmp6_code_)) + sizeof(icmp6_type_));
  // @@protoc_insertion_point(copy_constructor:Icmp6Hdr)
}

void Icmp6Hdr::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&icmp6_code_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&icmp6_dataun_) -
    reinterpret_cast<char*>(&icmp6_code_)) + sizeof(icmp6_dataun_));
icmp6_type_ = 1;
}

Icmp6Hdr::~Icmp6Hdr() {
  // @@protoc_insertion_point(destructor:Icmp6Hdr)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Icmp6Hdr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Icmp6Hdr::ArenaDtor(void* object) {
  Icmp6Hdr* _this = reinterpret_cast< Icmp6Hdr* >(object);
  (void)_this;
}
void Icmp6Hdr::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Icmp6Hdr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Icmp6Hdr::Clear() {
// @@protoc_insertion_point(message_clear_start:Icmp6Hdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&icmp6_code_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&icmp6_dataun_) -
        reinterpret_cast<char*>(&icmp6_code_)) + sizeof(icmp6_dataun_));
    icmp6_type_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Icmp6Hdr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .Icmp6Type icmp6_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Icmp6Type_IsValid(val))) {
            _internal_set_icmp6_type(static_cast<::Icmp6Type>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .Icmp6Code icmp6_code = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Icmp6Code_IsValid(val))) {
            _internal_set_icmp6_code(static_cast<::Icmp6Code>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional uint32 icmp6_dataun = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_icmp6_dataun(&has_bits);
          icmp6_dataun_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Icmp6Hdr::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Icmp6Hdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .Icmp6Type icmp6_type = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_icmp6_type(), target);
  }

  // optional .Icmp6Code icmp6_code = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_icmp6_code(), target);
  }

  // optional uint32 icmp6_dataun = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_icmp6_dataun(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Icmp6Hdr)
  return target;
}

size_t Icmp6Hdr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Icmp6Hdr)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional .Icmp6Code icmp6_code = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_icmp6_code());
    }

    // optional uint32 icmp6_dataun = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_icmp6_dataun());
    }

    // optional .Icmp6Type icmp6_type = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_icmp6_type());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Icmp6Hdr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Icmp6Hdr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Icmp6Hdr::GetClassData() const { return &_class_data_; }

void Icmp6Hdr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Icmp6Hdr *>(to)->MergeFrom(
      static_cast<const Icmp6Hdr &>(from));
}


void Icmp6Hdr::MergeFrom(const Icmp6Hdr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Icmp6Hdr)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      icmp6_code_ = from.icmp6_code_;
    }
    if (cached_has_bits & 0x00000002u) {
      icmp6_dataun_ = from.icmp6_dataun_;
    }
    if (cached_has_bits & 0x00000004u) {
      icmp6_type_ = from.icmp6_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Icmp6Hdr::CopyFrom(const Icmp6Hdr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Icmp6Hdr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Icmp6Hdr::IsInitialized() const {
  return true;
}

void Icmp6Hdr::InternalSwap(Icmp6Hdr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Icmp6Hdr, icmp6_dataun_)
      + sizeof(Icmp6Hdr::icmp6_dataun_)
      - PROTOBUF_FIELD_OFFSET(Icmp6Hdr, icmp6_code_)>(
          reinterpret_cast<char*>(&icmp6_code_),
          reinterpret_cast<char*>(&other->icmp6_code_));
  swap(icmp6_type_, other->icmp6_type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Icmp6Hdr::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[52]);
}

// ===================================================================

class TcpHdr::_Internal {
 public:
  using HasBits = decltype(std::declval<TcpHdr>()._has_bits_);
  static void set_has_th_sport(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_th_dport(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_th_seq(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_th_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_th_off(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_th_win(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_th_sum(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_th_urp(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_is_pure_syn(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_is_pure_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x000003ff) ^ 0x000003ff) != 0;
  }
};

TcpHdr::TcpHdr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  th_flags_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:TcpHdr)
}
TcpHdr::TcpHdr(const TcpHdr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      th_flags_(from.th_flags_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&th_sport_, &from.th_sport_,
    static_cast<size_t>(reinterpret_cast<char*>(&th_ack_) -
    reinterpret_cast<char*>(&th_sport_)) + sizeof(th_ack_));
  // @@protoc_insertion_point(copy_constructor:TcpHdr)
}

void TcpHdr::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&th_sport_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&is_pure_ack_) -
    reinterpret_cast<char*>(&th_sport_)) + sizeof(is_pure_ack_));
th_seq_ = 1;
th_ack_ = 1;
}

TcpHdr::~TcpHdr() {
  // @@protoc_insertion_point(destructor:TcpHdr)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void TcpHdr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void TcpHdr::ArenaDtor(void* object) {
  TcpHdr* _this = reinterpret_cast< TcpHdr* >(object);
  (void)_this;
}
void TcpHdr::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void TcpHdr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void TcpHdr::Clear() {
// @@protoc_insertion_point(message_clear_start:TcpHdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  th_flags_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    ::memset(&th_sport_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&is_pure_ack_) -
        reinterpret_cast<char*>(&th_sport_)) + sizeof(is_pure_ack_));
  }
  if (cached_has_bits & 0x00000300u) {
    th_seq_ = 1;
    th_ack_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* TcpHdr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .Port th_sport = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Port_IsValid(val))) {
            _internal_set_th_sport(static_cast<::Port>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .Port th_dport = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Port_IsValid(val))) {
            _internal_set_th_dport(static_cast<::Port>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .TcpSeq th_seq = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::TcpSeq_IsValid(val))) {
            _internal_set_th_seq(static_cast<::TcpSeq>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .TcpSeq th_ack = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::TcpSeq_IsValid(val))) {
            _internal_set_th_ack(static_cast<::TcpSeq>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required uint32 th_off = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_th_off(&has_bits);
          th_off_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .TcpFlag th_flags = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          ptr -= 1;
          do {
            ptr += 1;
            ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
            if (PROTOBUF_PREDICT_TRUE(::TcpFlag_IsValid(val))) {
              _internal_add_th_flags(static_cast<::TcpFlag>(val));
            } else {
              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
            }
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<48>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(_internal_mutable_th_flags(), ptr, ctx, ::TcpFlag_IsValid, &_internal_metadata_, 6);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 th_win = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_th_win(&has_bits);
          th_win_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 th_sum = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_th_sum(&has_bits);
          th_sum_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 th_urp = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_th_urp(&has_bits);
          th_urp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required bool is_pure_syn = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          _Internal::set_has_is_pure_syn(&has_bits);
          is_pure_syn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required bool is_pure_ack = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
          _Internal::set_has_is_pure_ack(&has_bits);
          is_pure_ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* TcpHdr::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:TcpHdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .Port th_sport = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_th_sport(), target);
  }

  // required .Port th_dport = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_th_dport(), target);
  }

  // required .TcpSeq th_seq = 3;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_th_seq(), target);
  }

  // required .TcpSeq th_ack = 4;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      4, this->_internal_th_ack(), target);
  }

  // required uint32 th_off = 5;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_th_off(), target);
  }

  // repeated .TcpFlag th_flags = 6;
  for (int i = 0, n = this->_internal_th_flags_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        6, this->_internal_th_flags(i), target);
  }

  // required uint32 th_win = 7;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_th_win(), target);
  }

  // required uint32 th_sum = 8;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(8, this->_internal_th_sum(), target);
  }

  // required uint32 th_urp = 9;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_th_urp(), target);
  }

  // required bool is_pure_syn = 10;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(10, this->_internal_is_pure_syn(), target);
  }

  // required bool is_pure_ack = 11;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(11, this->_internal_is_pure_ack(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:TcpHdr)
  return target;
}

size_t TcpHdr::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:TcpHdr)
  size_t total_size = 0;

  if (_internal_has_th_sport()) {
    // required .Port th_sport = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_th_sport());
  }

  if (_internal_has_th_dport()) {
    // required .Port th_dport = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_th_dport());
  }

  if (_internal_has_th_off()) {
    // required uint32 th_off = 5;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_th_off());
  }

  if (_internal_has_th_win()) {
    // required uint32 th_win = 7;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_th_win());
  }

  if (_internal_has_th_sum()) {
    // required uint32 th_sum = 8;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_th_sum());
  }

  if (_internal_has_th_urp()) {
    // required uint32 th_urp = 9;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_th_urp());
  }

  if (_internal_has_is_pure_syn()) {
    // required bool is_pure_syn = 10;
    total_size += 1 + 1;
  }

  if (_internal_has_is_pure_ack()) {
    // required bool is_pure_ack = 11;
    total_size += 1 + 1;
  }

  if (_internal_has_th_seq()) {
    // required .TcpSeq th_seq = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_th_seq());
  }

  if (_internal_has_th_ack()) {
    // required .TcpSeq th_ack = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_th_ack());
  }

  return total_size;
}
size_t TcpHdr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:TcpHdr)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x000003ff) ^ 0x000003ff) == 0) {  // All required fields are present.
    // required .Port th_sport = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_th_sport());

    // required .Port th_dport = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_th_dport());

    // required uint32 th_off = 5;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_th_off());

    // required uint32 th_win = 7;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_th_win());

    // required uint32 th_sum = 8;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_th_sum());

    // required uint32 th_urp = 9;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_th_urp());

    // required bool is_pure_syn = 10;
    total_size += 1 + 1;

    // required bool is_pure_ack = 11;
    total_size += 1 + 1;

    // required .TcpSeq th_seq = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_th_seq());

    // required .TcpSeq th_ack = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_th_ack());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .TcpFlag th_flags = 6;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->_internal_th_flags_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
        this->_internal_th_flags(static_cast<int>(i)));
    }
    total_size += (1UL * count) + data_size;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TcpHdr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    TcpHdr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TcpHdr::GetClassData() const { return &_class_data_; }

void TcpHdr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<TcpHdr *>(to)->MergeFrom(
      static_cast<const TcpHdr &>(from));
}


void TcpHdr::MergeFrom(const TcpHdr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:TcpHdr)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  th_flags_.MergeFrom(from.th_flags_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      th_sport_ = from.th_sport_;
    }
    if (cached_has_bits & 0x00000002u) {
      th_dport_ = from.th_dport_;
    }
    if (cached_has_bits & 0x00000004u) {
      th_off_ = from.th_off_;
    }
    if (cached_has_bits & 0x00000008u) {
      th_win_ = from.th_win_;
    }
    if (cached_has_bits & 0x00000010u) {
      th_sum_ = from.th_sum_;
    }
    if (cached_has_bits & 0x00000020u) {
      th_urp_ = from.th_urp_;
    }
    if (cached_has_bits & 0x00000040u) {
      is_pure_syn_ = from.is_pure_syn_;
    }
    if (cached_has_bits & 0x00000080u) {
      is_pure_ack_ = from.is_pure_ack_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000300u) {
    if (cached_has_bits & 0x00000100u) {
      th_seq_ = from.th_seq_;
    }
    if (cached_has_bits & 0x00000200u) {
      th_ack_ = from.th_ack_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void TcpHdr::CopyFrom(const TcpHdr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:TcpHdr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TcpHdr::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void TcpHdr::InternalSwap(TcpHdr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  th_flags_.InternalSwap(&other->th_flags_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(TcpHdr, is_pure_ack_)
      + sizeof(TcpHdr::is_pure_ack_)
      - PROTOBUF_FIELD_OFFSET(TcpHdr, th_sport_)>(
          reinterpret_cast<char*>(&th_sport_),
          reinterpret_cast<char*>(&other->th_sport_));
  swap(th_seq_, other->th_seq_);
  swap(th_ack_, other->th_ack_);
}

::PROTOBUF_NAMESPACE_ID::Metadata TcpHdr::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[53]);
}

// ===================================================================

class IpHdr::_Internal {
 public:
  using HasBits = decltype(std::declval<IpHdr>()._has_bits_);
  static void set_has_ip_hl(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_ip_v(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_ip_tos(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_ip_len(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_ip_id(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_ip_off(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_ip_ttl(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_ip_p(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_ip_src(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_ip_dst(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x000003ff) ^ 0x000003ff) != 0;
  }
};

IpHdr::IpHdr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:IpHdr)
}
IpHdr::IpHdr(const IpHdr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&ip_hl_, &from.ip_hl_,
    static_cast<size_t>(reinterpret_cast<char*>(&ip_v_) -
    reinterpret_cast<char*>(&ip_hl_)) + sizeof(ip_v_));
  // @@protoc_insertion_point(copy_constructor:IpHdr)
}

void IpHdr::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&ip_hl_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&ip_dst_) -
    reinterpret_cast<char*>(&ip_hl_)) + sizeof(ip_dst_));
ip_v_ = 4;
}

IpHdr::~IpHdr() {
  // @@protoc_insertion_point(destructor:IpHdr)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void IpHdr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void IpHdr::ArenaDtor(void* object) {
  IpHdr* _this = reinterpret_cast< IpHdr* >(object);
  (void)_this;
}
void IpHdr::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void IpHdr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void IpHdr::Clear() {
// @@protoc_insertion_point(message_clear_start:IpHdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    ::memset(&ip_hl_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&ip_src_) -
        reinterpret_cast<char*>(&ip_hl_)) + sizeof(ip_src_));
  }
  if (cached_has_bits & 0x00000300u) {
    ip_dst_ = 0;
    ip_v_ = 4;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* IpHdr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required uint32 ip_hl = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ip_hl(&has_bits);
          ip_hl_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .IpVersion ip_v = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::IpVersion_IsValid(val))) {
            _internal_set_ip_v(static_cast<::IpVersion>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip_tos = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_ip_tos(&has_bits);
          ip_tos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip_len = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_ip_len(&has_bits);
          ip_len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip_id = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_ip_id(&has_bits);
          ip_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip_off = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_ip_off(&has_bits);
          ip_off_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip_ttl = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_ip_ttl(&has_bits);
          ip_ttl_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .Protocol ip_p = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Protocol_IsValid(val))) {
            _internal_set_ip_p(static_cast<::Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .InAddr ip_src = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::InAddr_IsValid(val))) {
            _internal_set_ip_src(static_cast<::InAddr>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .InAddr ip_dst = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::InAddr_IsValid(val))) {
            _internal_set_ip_dst(static_cast<::InAddr>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* IpHdr::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:IpHdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint32 ip_hl = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_ip_hl(), target);
  }

  // required .IpVersion ip_v = 2;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_ip_v(), target);
  }

  // required uint32 ip_tos = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_ip_tos(), target);
  }

  // required uint32 ip_len = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_ip_len(), target);
  }

  // required uint32 ip_id = 5;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_ip_id(), target);
  }

  // required uint32 ip_off = 6;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_ip_off(), target);
  }

  // required uint32 ip_ttl = 7;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_ip_ttl(), target);
  }

  // required .Protocol ip_p = 8;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      8, this->_internal_ip_p(), target);
  }

  // required .InAddr ip_src = 9;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      9, this->_internal_ip_src(), target);
  }

  // required .InAddr ip_dst = 10;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      10, this->_internal_ip_dst(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:IpHdr)
  return target;
}

size_t IpHdr::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:IpHdr)
  size_t total_size = 0;

  if (_internal_has_ip_hl()) {
    // required uint32 ip_hl = 1;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_hl());
  }

  if (_internal_has_ip_tos()) {
    // required uint32 ip_tos = 3;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_tos());
  }

  if (_internal_has_ip_len()) {
    // required uint32 ip_len = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_len());
  }

  if (_internal_has_ip_id()) {
    // required uint32 ip_id = 5;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_id());
  }

  if (_internal_has_ip_off()) {
    // required uint32 ip_off = 6;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_off());
  }

  if (_internal_has_ip_ttl()) {
    // required uint32 ip_ttl = 7;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_ttl());
  }

  if (_internal_has_ip_p()) {
    // required .Protocol ip_p = 8;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip_p());
  }

  if (_internal_has_ip_src()) {
    // required .InAddr ip_src = 9;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip_src());
  }

  if (_internal_has_ip_dst()) {
    // required .InAddr ip_dst = 10;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip_dst());
  }

  if (_internal_has_ip_v()) {
    // required .IpVersion ip_v = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip_v());
  }

  return total_size;
}
size_t IpHdr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:IpHdr)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x000003ff) ^ 0x000003ff) == 0) {  // All required fields are present.
    // required uint32 ip_hl = 1;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_hl());

    // required uint32 ip_tos = 3;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_tos());

    // required uint32 ip_len = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_len());

    // required uint32 ip_id = 5;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_id());

    // required uint32 ip_off = 6;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_off());

    // required uint32 ip_ttl = 7;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_ttl());

    // required .Protocol ip_p = 8;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip_p());

    // required .InAddr ip_src = 9;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip_src());

    // required .InAddr ip_dst = 10;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip_dst());

    // required .IpVersion ip_v = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip_v());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData IpHdr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    IpHdr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*IpHdr::GetClassData() const { return &_class_data_; }

void IpHdr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<IpHdr *>(to)->MergeFrom(
      static_cast<const IpHdr &>(from));
}


void IpHdr::MergeFrom(const IpHdr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:IpHdr)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      ip_hl_ = from.ip_hl_;
    }
    if (cached_has_bits & 0x00000002u) {
      ip_tos_ = from.ip_tos_;
    }
    if (cached_has_bits & 0x00000004u) {
      ip_len_ = from.ip_len_;
    }
    if (cached_has_bits & 0x00000008u) {
      ip_id_ = from.ip_id_;
    }
    if (cached_has_bits & 0x00000010u) {
      ip_off_ = from.ip_off_;
    }
    if (cached_has_bits & 0x00000020u) {
      ip_ttl_ = from.ip_ttl_;
    }
    if (cached_has_bits & 0x00000040u) {
      ip_p_ = from.ip_p_;
    }
    if (cached_has_bits & 0x00000080u) {
      ip_src_ = from.ip_src_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000300u) {
    if (cached_has_bits & 0x00000100u) {
      ip_dst_ = from.ip_dst_;
    }
    if (cached_has_bits & 0x00000200u) {
      ip_v_ = from.ip_v_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void IpHdr::CopyFrom(const IpHdr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:IpHdr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool IpHdr::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void IpHdr::InternalSwap(IpHdr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(IpHdr, ip_dst_)
      + sizeof(IpHdr::ip_dst_)
      - PROTOBUF_FIELD_OFFSET(IpHdr, ip_hl_)>(
          reinterpret_cast<char*>(&ip_hl_),
          reinterpret_cast<char*>(&other->ip_hl_));
  swap(ip_v_, other->ip_v_);
}

::PROTOBUF_NAMESPACE_ID::Metadata IpHdr::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[54]);
}

// ===================================================================

class Ip6Hdr::_Internal {
 public:
  using HasBits = decltype(std::declval<Ip6Hdr>()._has_bits_);
  static const ::Ip6Hdrctl& ip6_hdrctl(const Ip6Hdr* msg);
  static void set_has_ip6_hdrctl(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_ip6_src(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_ip6_dst(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
  }
};

const ::Ip6Hdrctl&
Ip6Hdr::_Internal::ip6_hdrctl(const Ip6Hdr* msg) {
  return *msg->ip6_hdrctl_;
}
Ip6Hdr::Ip6Hdr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Ip6Hdr)
}
Ip6Hdr::Ip6Hdr(const Ip6Hdr& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_ip6_hdrctl()) {
    ip6_hdrctl_ = new ::Ip6Hdrctl(*from.ip6_hdrctl_);
  } else {
    ip6_hdrctl_ = nullptr;
  }
  ::memcpy(&ip6_src_, &from.ip6_src_,
    static_cast<size_t>(reinterpret_cast<char*>(&ip6_dst_) -
    reinterpret_cast<char*>(&ip6_src_)) + sizeof(ip6_dst_));
  // @@protoc_insertion_point(copy_constructor:Ip6Hdr)
}

void Ip6Hdr::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&ip6_hdrctl_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&ip6_dst_) -
    reinterpret_cast<char*>(&ip6_hdrctl_)) + sizeof(ip6_dst_));
}

Ip6Hdr::~Ip6Hdr() {
  // @@protoc_insertion_point(destructor:Ip6Hdr)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Ip6Hdr::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete ip6_hdrctl_;
}

void Ip6Hdr::ArenaDtor(void* object) {
  Ip6Hdr* _this = reinterpret_cast< Ip6Hdr* >(object);
  (void)_this;
}
void Ip6Hdr::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Ip6Hdr::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Ip6Hdr::Clear() {
// @@protoc_insertion_point(message_clear_start:Ip6Hdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(ip6_hdrctl_ != nullptr);
    ip6_hdrctl_->Clear();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&ip6_src_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&ip6_dst_) -
        reinterpret_cast<char*>(&ip6_src_)) + sizeof(ip6_dst_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Ip6Hdr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .Ip6Hdrctl ip6_hdrctl = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_ip6_hdrctl(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .In6Addr ip6_src = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::In6Addr_IsValid(val))) {
            _internal_set_ip6_src(static_cast<::In6Addr>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .In6Addr ip6_dst = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::In6Addr_IsValid(val))) {
            _internal_set_ip6_dst(static_cast<::In6Addr>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Ip6Hdr::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Ip6Hdr)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .Ip6Hdrctl ip6_hdrctl = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::ip6_hdrctl(this), target, stream);
  }

  // required .In6Addr ip6_src = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_ip6_src(), target);
  }

  // required .In6Addr ip6_dst = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_ip6_dst(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Ip6Hdr)
  return target;
}

size_t Ip6Hdr::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Ip6Hdr)
  size_t total_size = 0;

  if (_internal_has_ip6_hdrctl()) {
    // required .Ip6Hdrctl ip6_hdrctl = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ip6_hdrctl_);
  }

  if (_internal_has_ip6_src()) {
    // required .In6Addr ip6_src = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6_src());
  }

  if (_internal_has_ip6_dst()) {
    // required .In6Addr ip6_dst = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6_dst());
  }

  return total_size;
}
size_t Ip6Hdr::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Ip6Hdr)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required .Ip6Hdrctl ip6_hdrctl = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ip6_hdrctl_);

    // required .In6Addr ip6_src = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6_src());

    // required .In6Addr ip6_dst = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6_dst());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Ip6Hdr::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Ip6Hdr::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Ip6Hdr::GetClassData() const { return &_class_data_; }

void Ip6Hdr::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Ip6Hdr *>(to)->MergeFrom(
      static_cast<const Ip6Hdr &>(from));
}


void Ip6Hdr::MergeFrom(const Ip6Hdr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Ip6Hdr)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_ip6_hdrctl()->::Ip6Hdrctl::MergeFrom(from._internal_ip6_hdrctl());
    }
    if (cached_has_bits & 0x00000002u) {
      ip6_src_ = from.ip6_src_;
    }
    if (cached_has_bits & 0x00000004u) {
      ip6_dst_ = from.ip6_dst_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Ip6Hdr::CopyFrom(const Ip6Hdr& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Ip6Hdr)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Ip6Hdr::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_ip6_hdrctl()) {
    if (!ip6_hdrctl_->IsInitialized()) return false;
  }
  return true;
}

void Ip6Hdr::InternalSwap(Ip6Hdr* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Ip6Hdr, ip6_dst_)
      + sizeof(Ip6Hdr::ip6_dst_)
      - PROTOBUF_FIELD_OFFSET(Ip6Hdr, ip6_hdrctl_)>(
          reinterpret_cast<char*>(&ip6_hdrctl_),
          reinterpret_cast<char*>(&other->ip6_hdrctl_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Ip6Hdr::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[55]);
}

// ===================================================================

class Ip6Hdrctl::_Internal {
 public:
  using HasBits = decltype(std::declval<Ip6Hdrctl>()._has_bits_);
  static void set_has_ip6_un1_flow(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_ip6_un1_plen(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_ip6_un1_nxt(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_ip6_un1_hlim(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000000f) ^ 0x0000000f) != 0;
  }
};

Ip6Hdrctl::Ip6Hdrctl(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Ip6Hdrctl)
}
Ip6Hdrctl::Ip6Hdrctl(const Ip6Hdrctl& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&ip6_un1_flow_, &from.ip6_un1_flow_,
    static_cast<size_t>(reinterpret_cast<char*>(&ip6_un1_hlim_) -
    reinterpret_cast<char*>(&ip6_un1_flow_)) + sizeof(ip6_un1_hlim_));
  // @@protoc_insertion_point(copy_constructor:Ip6Hdrctl)
}

void Ip6Hdrctl::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&ip6_un1_flow_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&ip6_un1_hlim_) -
    reinterpret_cast<char*>(&ip6_un1_flow_)) + sizeof(ip6_un1_hlim_));
}

Ip6Hdrctl::~Ip6Hdrctl() {
  // @@protoc_insertion_point(destructor:Ip6Hdrctl)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Ip6Hdrctl::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Ip6Hdrctl::ArenaDtor(void* object) {
  Ip6Hdrctl* _this = reinterpret_cast< Ip6Hdrctl* >(object);
  (void)_this;
}
void Ip6Hdrctl::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Ip6Hdrctl::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Ip6Hdrctl::Clear() {
// @@protoc_insertion_point(message_clear_start:Ip6Hdrctl)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    ::memset(&ip6_un1_flow_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&ip6_un1_hlim_) -
        reinterpret_cast<char*>(&ip6_un1_flow_)) + sizeof(ip6_un1_hlim_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Ip6Hdrctl::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required uint32 ip6_un1_flow = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ip6_un1_flow(&has_bits);
          ip6_un1_flow_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6_un1_plen = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_ip6_un1_plen(&has_bits);
          ip6_un1_plen_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // required .Protocol ip6_un1_nxt = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Protocol_IsValid(val))) {
            _internal_set_ip6_un1_nxt(static_cast<::Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required uint32 ip6_un1_hlim = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_ip6_un1_hlim(&has_bits);
          ip6_un1_hlim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Ip6Hdrctl::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Ip6Hdrctl)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint32 ip6_un1_flow = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_ip6_un1_flow(), target);
  }

  // required uint32 ip6_un1_plen = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_ip6_un1_plen(), target);
  }

  // required .Protocol ip6_un1_nxt = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_ip6_un1_nxt(), target);
  }

  // required uint32 ip6_un1_hlim = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_ip6_un1_hlim(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Ip6Hdrctl)
  return target;
}

size_t Ip6Hdrctl::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Ip6Hdrctl)
  size_t total_size = 0;

  if (_internal_has_ip6_un1_flow()) {
    // required uint32 ip6_un1_flow = 1;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6_un1_flow());
  }

  if (_internal_has_ip6_un1_plen()) {
    // required uint32 ip6_un1_plen = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6_un1_plen());
  }

  if (_internal_has_ip6_un1_nxt()) {
    // required .Protocol ip6_un1_nxt = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6_un1_nxt());
  }

  if (_internal_has_ip6_un1_hlim()) {
    // required uint32 ip6_un1_hlim = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6_un1_hlim());
  }

  return total_size;
}
size_t Ip6Hdrctl::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Ip6Hdrctl)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x0000000f) ^ 0x0000000f) == 0) {  // All required fields are present.
    // required uint32 ip6_un1_flow = 1;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6_un1_flow());

    // required uint32 ip6_un1_plen = 2;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6_un1_plen());

    // required .Protocol ip6_un1_nxt = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ip6_un1_nxt());

    // required uint32 ip6_un1_hlim = 4;
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_ip6_un1_hlim());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Ip6Hdrctl::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Ip6Hdrctl::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Ip6Hdrctl::GetClassData() const { return &_class_data_; }

void Ip6Hdrctl::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Ip6Hdrctl *>(to)->MergeFrom(
      static_cast<const Ip6Hdrctl &>(from));
}


void Ip6Hdrctl::MergeFrom(const Ip6Hdrctl& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Ip6Hdrctl)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      ip6_un1_flow_ = from.ip6_un1_flow_;
    }
    if (cached_has_bits & 0x00000002u) {
      ip6_un1_plen_ = from.ip6_un1_plen_;
    }
    if (cached_has_bits & 0x00000004u) {
      ip6_un1_nxt_ = from.ip6_un1_nxt_;
    }
    if (cached_has_bits & 0x00000008u) {
      ip6_un1_hlim_ = from.ip6_un1_hlim_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Ip6Hdrctl::CopyFrom(const Ip6Hdrctl& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Ip6Hdrctl)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Ip6Hdrctl::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void Ip6Hdrctl::InternalSwap(Ip6Hdrctl* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Ip6Hdrctl, ip6_un1_hlim_)
      + sizeof(Ip6Hdrctl::ip6_un1_hlim_)
      - PROTOBUF_FIELD_OFFSET(Ip6Hdrctl, ip6_un1_flow_)>(
          reinterpret_cast<char*>(&ip6_un1_flow_),
          reinterpret_cast<char*>(&other->ip6_un1_flow_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Ip6Hdrctl::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[56]);
}

// ===================================================================

class Key::_Internal {
 public:
  using HasBits = decltype(std::declval<Key>()._has_bits_);
  static void set_has_mbuf_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

Key::Key(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Key)
}
Key::Key(const Key& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  mbuf_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_mbuf_data()) {
    mbuf_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_mbuf_data(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:Key)
}

void Key::SharedCtor() {
mbuf_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

Key::~Key() {
  // @@protoc_insertion_point(destructor:Key)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Key::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  mbuf_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Key::ArenaDtor(void* object) {
  Key* _this = reinterpret_cast< Key* >(object);
  (void)_this;
}
void Key::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Key::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Key::Clear() {
// @@protoc_insertion_point(message_clear_start:Key)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    mbuf_data_.ClearNonDefaultToEmpty();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Key::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required bytes mbuf_data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_mbuf_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Key::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Key)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required bytes mbuf_data = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_mbuf_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Key)
  return target;
}

size_t Key::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Key)
  size_t total_size = 0;

  // required bytes mbuf_data = 1;
  if (_internal_has_mbuf_data()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_mbuf_data());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Key::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Key::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Key::GetClassData() const { return &_class_data_; }

void Key::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Key *>(to)->MergeFrom(
      static_cast<const Key &>(from));
}


void Key::MergeFrom(const Key& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Key)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_mbuf_data()) {
    _internal_set_mbuf_data(from._internal_mbuf_data());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Key::CopyFrom(const Key& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Key)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Key::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void Key::InternalSwap(Key* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &mbuf_data_, lhs_arena,
      &other->mbuf_data_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata Key::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[57]);
}

// ===================================================================

class Ioctl::_Internal {
 public:
  using HasBits = decltype(std::declval<Ioctl>()._has_bits_);
  static void set_has_ioctl_idx(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_fd(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

Ioctl::Ioctl(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Ioctl)
}
Ioctl::Ioctl(const Ioctl& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&fd_, &from.fd_,
    static_cast<size_t>(reinterpret_cast<char*>(&ioctl_idx_) -
    reinterpret_cast<char*>(&fd_)) + sizeof(ioctl_idx_));
  // @@protoc_insertion_point(copy_constructor:Ioctl)
}

void Ioctl::SharedCtor() {
fd_ = 0;
ioctl_idx_ = 1;
}

Ioctl::~Ioctl() {
  // @@protoc_insertion_point(destructor:Ioctl)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Ioctl::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Ioctl::ArenaDtor(void* object) {
  Ioctl* _this = reinterpret_cast< Ioctl* >(object);
  (void)_this;
}
void Ioctl::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Ioctl::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Ioctl::Clear() {
// @@protoc_insertion_point(message_clear_start:Ioctl)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    fd_ = 0;
    ioctl_idx_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Ioctl::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .IoctlIdx ioctl_idx = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::IoctlIdx_IsValid(val))) {
            _internal_set_ioctl_idx(static_cast<::IoctlIdx>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .FileDescriptor fd = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_fd(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Ioctl::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Ioctl)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .IoctlIdx ioctl_idx = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_ioctl_idx(), target);
  }

  // required .FileDescriptor fd = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_fd(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Ioctl)
  return target;
}

size_t Ioctl::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Ioctl)
  size_t total_size = 0;

  if (_internal_has_fd()) {
    // required .FileDescriptor fd = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fd());
  }

  if (_internal_has_ioctl_idx()) {
    // required .IoctlIdx ioctl_idx = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ioctl_idx());
  }

  return total_size;
}
size_t Ioctl::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Ioctl)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required .FileDescriptor fd = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fd());

    // required .IoctlIdx ioctl_idx = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ioctl_idx());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Ioctl::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Ioctl::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Ioctl::GetClassData() const { return &_class_data_; }

void Ioctl::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Ioctl *>(to)->MergeFrom(
      static_cast<const Ioctl &>(from));
}


void Ioctl::MergeFrom(const Ioctl& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Ioctl)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      fd_ = from.fd_;
    }
    if (cached_has_bits & 0x00000002u) {
      ioctl_idx_ = from.ioctl_idx_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Ioctl::CopyFrom(const Ioctl& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Ioctl)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Ioctl::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void Ioctl::InternalSwap(Ioctl* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(fd_, other->fd_);
  swap(ioctl_idx_, other->ioctl_idx_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Ioctl::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[58]);
}

// ===================================================================

class SetSocketOpt::_Internal {
 public:
  using HasBits = decltype(std::declval<SetSocketOpt>()._has_bits_);
  static void set_has_level(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_val(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_fd(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

SetSocketOpt::SetSocketOpt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:SetSocketOpt)
}
SetSocketOpt::SetSocketOpt(const SetSocketOpt& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  val_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_val()) {
    val_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_val(), 
      GetArenaForAllocation());
  }
  ::memcpy(&level_, &from.level_,
    static_cast<size_t>(reinterpret_cast<char*>(&name_) -
    reinterpret_cast<char*>(&level_)) + sizeof(name_));
  // @@protoc_insertion_point(copy_constructor:SetSocketOpt)
}

void SetSocketOpt::SharedCtor() {
val_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&level_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&fd_) -
    reinterpret_cast<char*>(&level_)) + sizeof(fd_));
name_ = 1;
}

SetSocketOpt::~SetSocketOpt() {
  // @@protoc_insertion_point(destructor:SetSocketOpt)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void SetSocketOpt::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  val_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void SetSocketOpt::ArenaDtor(void* object) {
  SetSocketOpt* _this = reinterpret_cast< SetSocketOpt* >(object);
  (void)_this;
}
void SetSocketOpt::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SetSocketOpt::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SetSocketOpt::Clear() {
// @@protoc_insertion_point(message_clear_start:SetSocketOpt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    val_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x0000000eu) {
    ::memset(&level_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&fd_) -
        reinterpret_cast<char*>(&level_)) + sizeof(fd_));
    name_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* SetSocketOpt::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .Protocol level = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Protocol_IsValid(val))) {
            _internal_set_level(static_cast<::Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .SocketOptName name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SocketOptName_IsValid(val))) {
            _internal_set_name(static_cast<::SocketOptName>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional bytes val = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_val();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .FileDescriptor fd = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::FileDescriptor_IsValid(val))) {
            _internal_set_fd(static_cast<::FileDescriptor>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* SetSocketOpt::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SetSocketOpt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .Protocol level = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_level(), target);
  }

  // optional .SocketOptName name = 2;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_name(), target);
  }

  // optional bytes val = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        3, this->_internal_val(), target);
  }

  // optional .FileDescriptor fd = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      4, this->_internal_fd(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SetSocketOpt)
  return target;
}

size_t SetSocketOpt::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SetSocketOpt)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional bytes val = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_val());
    }

    // optional .Protocol level = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_level());
    }

    // optional .FileDescriptor fd = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fd());
    }

    // optional .SocketOptName name = 2;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_name());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SetSocketOpt::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    SetSocketOpt::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetSocketOpt::GetClassData() const { return &_class_data_; }

void SetSocketOpt::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<SetSocketOpt *>(to)->MergeFrom(
      static_cast<const SetSocketOpt &>(from));
}


void SetSocketOpt::MergeFrom(const SetSocketOpt& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SetSocketOpt)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_val(from._internal_val());
    }
    if (cached_has_bits & 0x00000002u) {
      level_ = from.level_;
    }
    if (cached_has_bits & 0x00000004u) {
      fd_ = from.fd_;
    }
    if (cached_has_bits & 0x00000008u) {
      name_ = from.name_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void SetSocketOpt::CopyFrom(const SetSocketOpt& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:SetSocketOpt)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SetSocketOpt::IsInitialized() const {
  return true;
}

void SetSocketOpt::InternalSwap(SetSocketOpt* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &val_, lhs_arena,
      &other->val_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SetSocketOpt, fd_)
      + sizeof(SetSocketOpt::fd_)
      - PROTOBUF_FIELD_OFFSET(SetSocketOpt, level_)>(
          reinterpret_cast<char*>(&level_),
          reinterpret_cast<char*>(&other->level_));
  swap(name_, other->name_);
}

::PROTOBUF_NAMESPACE_ID::Metadata SetSocketOpt::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[59]);
}

// ===================================================================

class GetSocketOpt::_Internal {
 public:
  using HasBits = decltype(std::declval<GetSocketOpt>()._has_bits_);
  static void set_has_level(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_fd(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

GetSocketOpt::GetSocketOpt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:GetSocketOpt)
}
GetSocketOpt::GetSocketOpt(const GetSocketOpt& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&level_, &from.level_,
    static_cast<size_t>(reinterpret_cast<char*>(&name_) -
    reinterpret_cast<char*>(&level_)) + sizeof(name_));
  // @@protoc_insertion_point(copy_constructor:GetSocketOpt)
}

void GetSocketOpt::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&level_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&fd_) -
    reinterpret_cast<char*>(&level_)) + sizeof(fd_));
name_ = 1;
}

GetSocketOpt::~GetSocketOpt() {
  // @@protoc_insertion_point(destructor:GetSocketOpt)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void GetSocketOpt::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void GetSocketOpt::ArenaDtor(void* object) {
  GetSocketOpt* _this = reinterpret_cast< GetSocketOpt* >(object);
  (void)_this;
}
void GetSocketOpt::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void GetSocketOpt::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void GetSocketOpt::Clear() {
// @@protoc_insertion_point(message_clear_start:GetSocketOpt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    ::memset(&level_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&fd_) -
        reinterpret_cast<char*>(&level_)) + sizeof(fd_));
    name_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* GetSocketOpt::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .Protocol level = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Protocol_IsValid(val))) {
            _internal_set_level(static_cast<::Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .SocketOptName name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SocketOptName_IsValid(val))) {
            _internal_set_name(static_cast<::SocketOptName>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional int32 size = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 fd = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_fd(&has_bits);
          fd_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* GetSocketOpt::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:GetSocketOpt)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .Protocol level = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_level(), target);
  }

  // optional .SocketOptName name = 2;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_name(), target);
  }

  // optional int32 size = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_size(), target);
  }

  // optional uint32 fd = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_fd(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:GetSocketOpt)
  return target;
}

size_t GetSocketOpt::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:GetSocketOpt)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional .Protocol level = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_level());
    }

    // optional int32 size = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_size());
    }

    // optional uint32 fd = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_fd());
    }

    // optional .SocketOptName name = 2;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_name());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData GetSocketOpt::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    GetSocketOpt::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetSocketOpt::GetClassData() const { return &_class_data_; }

void GetSocketOpt::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<GetSocketOpt *>(to)->MergeFrom(
      static_cast<const GetSocketOpt &>(from));
}


void GetSocketOpt::MergeFrom(const GetSocketOpt& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:GetSocketOpt)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      level_ = from.level_;
    }
    if (cached_has_bits & 0x00000002u) {
      size_ = from.size_;
    }
    if (cached_has_bits & 0x00000004u) {
      fd_ = from.fd_;
    }
    if (cached_has_bits & 0x00000008u) {
      name_ = from.name_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void GetSocketOpt::CopyFrom(const GetSocketOpt& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:GetSocketOpt)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetSocketOpt::IsInitialized() const {
  return true;
}

void GetSocketOpt::InternalSwap(GetSocketOpt* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(GetSocketOpt, fd_)
      + sizeof(GetSocketOpt::fd_)
      - PROTOBUF_FIELD_OFFSET(GetSocketOpt, level_)>(
          reinterpret_cast<char*>(&level_),
          reinterpret_cast<char*>(&other->level_));
  swap(name_, other->name_);
}

::PROTOBUF_NAMESPACE_ID::Metadata GetSocketOpt::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[60]);
}

// ===================================================================

class Socket::_Internal {
 public:
  using HasBits = decltype(std::declval<Socket>()._has_bits_);
  static void set_has_domain(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_so_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_protocol(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
  }
};

Socket::Socket(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:Socket)
}
Socket::Socket(const Socket& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&domain_, &from.domain_,
    static_cast<size_t>(reinterpret_cast<char*>(&so_type_) -
    reinterpret_cast<char*>(&domain_)) + sizeof(so_type_));
  // @@protoc_insertion_point(copy_constructor:Socket)
}

void Socket::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&domain_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&protocol_) -
    reinterpret_cast<char*>(&domain_)) + sizeof(protocol_));
so_type_ = 1;
}

Socket::~Socket() {
  // @@protoc_insertion_point(destructor:Socket)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Socket::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Socket::ArenaDtor(void* object) {
  Socket* _this = reinterpret_cast< Socket* >(object);
  (void)_this;
}
void Socket::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Socket::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Socket::Clear() {
// @@protoc_insertion_point(message_clear_start:Socket)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&domain_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&protocol_) -
        reinterpret_cast<char*>(&domain_)) + sizeof(protocol_));
    so_type_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Socket::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // required .Domain domain = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Domain_IsValid(val))) {
            _internal_set_domain(static_cast<::Domain>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .SoType so_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SoType_IsValid(val))) {
            _internal_set_so_type(static_cast<::SoType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // required .Protocol protocol = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::Protocol_IsValid(val))) {
            _internal_set_protocol(static_cast<::Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Socket::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Socket)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .Domain domain = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_domain(), target);
  }

  // required .SoType so_type = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_so_type(), target);
  }

  // required .Protocol protocol = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_protocol(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Socket)
  return target;
}

size_t Socket::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Socket)
  size_t total_size = 0;

  if (_internal_has_domain()) {
    // required .Domain domain = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_domain());
  }

  if (_internal_has_protocol()) {
    // required .Protocol protocol = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_protocol());
  }

  if (_internal_has_so_type()) {
    // required .SoType so_type = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_so_type());
  }

  return total_size;
}
size_t Socket::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Socket)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required .Domain domain = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_domain());

    // required .Protocol protocol = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_protocol());

    // required .SoType so_type = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_so_type());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Socket::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Socket::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Socket::GetClassData() const { return &_class_data_; }

void Socket::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Socket *>(to)->MergeFrom(
      static_cast<const Socket &>(from));
}


void Socket::MergeFrom(const Socket& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Socket)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      domain_ = from.domain_;
    }
    if (cached_has_bits & 0x00000002u) {
      protocol_ = from.protocol_;
    }
    if (cached_has_bits & 0x00000004u) {
      so_type_ = from.so_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Socket::CopyFrom(const Socket& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Socket)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Socket::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void Socket::InternalSwap(Socket* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Socket, protocol_)
      + sizeof(Socket::protocol_)
      - PROTOBUF_FIELD_OFFSET(Socket, domain_)>(
          reinterpret_cast<char*>(&domain_),
          reinterpret_cast<char*>(&other->domain_));
  swap(so_type_, other->so_type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Socket::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_net_5ffuzzer_2eproto_getter, &descriptor_table_net_5ffuzzer_2eproto_once,
      file_level_metadata_net_5ffuzzer_2eproto[61]);
}

// @@protoc_insertion_point(namespace_scope)
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::Session* Arena::CreateMaybeMessage< ::Session >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Session >(arena);
}
template<> PROTOBUF_NOINLINE ::Connect* Arena::CreateMaybeMessage< ::Connect >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Connect >(arena);
}
template<> PROTOBUF_NOINLINE ::ConnectX* Arena::CreateMaybeMessage< ::ConnectX >(Arena* arena) {
  return Arena::CreateMessageInternal< ::ConnectX >(arena);
}
template<> PROTOBUF_NOINLINE ::DisconnectX* Arena::CreateMaybeMessage< ::DisconnectX >(Arena* arena) {
  return Arena::CreateMessageInternal< ::DisconnectX >(arena);
}
template<> PROTOBUF_NOINLINE ::IOV* Arena::CreateMaybeMessage< ::IOV >(Arena* arena) {
  return Arena::CreateMessageInternal< ::IOV >(arena);
}
template<> PROTOBUF_NOINLINE ::Endpoints* Arena::CreateMaybeMessage< ::Endpoints >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Endpoints >(arena);
}
template<> PROTOBUF_NOINLINE ::SockAddr* Arena::CreateMaybeMessage< ::SockAddr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::SockAddr >(arena);
}
template<> PROTOBUF_NOINLINE ::SockAddrGeneric* Arena::CreateMaybeMessage< ::SockAddrGeneric >(Arena* arena) {
  return Arena::CreateMessageInternal< ::SockAddrGeneric >(arena);
}
template<> PROTOBUF_NOINLINE ::SockAddr4* Arena::CreateMaybeMessage< ::SockAddr4 >(Arena* arena) {
  return Arena::CreateMessageInternal< ::SockAddr4 >(arena);
}
template<> PROTOBUF_NOINLINE ::SockAddr6* Arena::CreateMaybeMessage< ::SockAddr6 >(Arena* arena) {
  return Arena::CreateMessageInternal< ::SockAddr6 >(arena);
}
template<> PROTOBUF_NOINLINE ::Command* Arena::CreateMaybeMessage< ::Command >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Command >(arena);
}
template<> PROTOBUF_NOINLINE ::AcceptNocancel* Arena::CreateMaybeMessage< ::AcceptNocancel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::AcceptNocancel >(arena);
}
template<> PROTOBUF_NOINLINE ::ConnectNocancel* Arena::CreateMaybeMessage< ::ConnectNocancel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::ConnectNocancel >(arena);
}
template<> PROTOBUF_NOINLINE ::Getpeername* Arena::CreateMaybeMessage< ::Getpeername >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Getpeername >(arena);
}
template<> PROTOBUF_NOINLINE ::Getsockname* Arena::CreateMaybeMessage< ::Getsockname >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Getsockname >(arena);
}
template<> PROTOBUF_NOINLINE ::Peeloff* Arena::CreateMaybeMessage< ::Peeloff >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Peeloff >(arena);
}
template<> PROTOBUF_NOINLINE ::Pipe* Arena::CreateMaybeMessage< ::Pipe >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Pipe >(arena);
}
template<> PROTOBUF_NOINLINE ::Shutdown* Arena::CreateMaybeMessage< ::Shutdown >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Shutdown >(arena);
}
template<> PROTOBUF_NOINLINE ::Recvfrom* Arena::CreateMaybeMessage< ::Recvfrom >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Recvfrom >(arena);
}
template<> PROTOBUF_NOINLINE ::RecvfromNocancel* Arena::CreateMaybeMessage< ::RecvfromNocancel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RecvfromNocancel >(arena);
}
template<> PROTOBUF_NOINLINE ::Recvmsg* Arena::CreateMaybeMessage< ::Recvmsg >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Recvmsg >(arena);
}
template<> PROTOBUF_NOINLINE ::Sendmsg* Arena::CreateMaybeMessage< ::Sendmsg >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Sendmsg >(arena);
}
template<> PROTOBUF_NOINLINE ::Sendto* Arena::CreateMaybeMessage< ::Sendto >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Sendto >(arena);
}
template<> PROTOBUF_NOINLINE ::Socketpair* Arena::CreateMaybeMessage< ::Socketpair >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Socketpair >(arena);
}
template<> PROTOBUF_NOINLINE ::NecpSessionOpen* Arena::CreateMaybeMessage< ::NecpSessionOpen >(Arena* arena) {
  return Arena::CreateMessageInternal< ::NecpSessionOpen >(arena);
}
template<> PROTOBUF_NOINLINE ::NecpSessionAction* Arena::CreateMaybeMessage< ::NecpSessionAction >(Arena* arena) {
  return Arena::CreateMessageInternal< ::NecpSessionAction >(arena);
}
template<> PROTOBUF_NOINLINE ::NecpMatchPolicy* Arena::CreateMaybeMessage< ::NecpMatchPolicy >(Arena* arena) {
  return Arena::CreateMessageInternal< ::NecpMatchPolicy >(arena);
}
template<> PROTOBUF_NOINLINE ::NecpOpen* Arena::CreateMaybeMessage< ::NecpOpen >(Arena* arena) {
  return Arena::CreateMessageInternal< ::NecpOpen >(arena);
}
template<> PROTOBUF_NOINLINE ::NecpClientAction* Arena::CreateMaybeMessage< ::NecpClientAction >(Arena* arena) {
  return Arena::CreateMessageInternal< ::NecpClientAction >(arena);
}
template<> PROTOBUF_NOINLINE ::NecpClientActionAdd* Arena::CreateMaybeMessage< ::NecpClientActionAdd >(Arena* arena) {
  return Arena::CreateMessageInternal< ::NecpClientActionAdd >(arena);
}
template<> PROTOBUF_NOINLINE ::NecpClientActionRemove* Arena::CreateMaybeMessage< ::NecpClientActionRemove >(Arena* arena) {
  return Arena::CreateMessageInternal< ::NecpClientActionRemove >(arena);
}
template<> PROTOBUF_NOINLINE ::NecpClientActionCopyParameters* Arena::CreateMaybeMessage< ::NecpClientActionCopyParameters >(Arena* arena) {
  return Arena::CreateMessageInternal< ::NecpClientActionCopyParameters >(arena);
}
template<> PROTOBUF_NOINLINE ::NecpClientActionAgent* Arena::CreateMaybeMessage< ::NecpClientActionAgent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::NecpClientActionAgent >(arena);
}
template<> PROTOBUF_NOINLINE ::NecpTlv* Arena::CreateMaybeMessage< ::NecpTlv >(Arena* arena) {
  return Arena::CreateMessageInternal< ::NecpTlv >(arena);
}
template<> PROTOBUF_NOINLINE ::ClearAll* Arena::CreateMaybeMessage< ::ClearAll >(Arena* arena) {
  return Arena::CreateMessageInternal< ::ClearAll >(arena);
}
template<> PROTOBUF_NOINLINE ::Close* Arena::CreateMaybeMessage< ::Close >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Close >(arena);
}
template<> PROTOBUF_NOINLINE ::Accept* Arena::CreateMaybeMessage< ::Accept >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Accept >(arena);
}
template<> PROTOBUF_NOINLINE ::Bind* Arena::CreateMaybeMessage< ::Bind >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Bind >(arena);
}
template<> PROTOBUF_NOINLINE ::Listen* Arena::CreateMaybeMessage< ::Listen >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Listen >(arena);
}
template<> PROTOBUF_NOINLINE ::IoctlReal* Arena::CreateMaybeMessage< ::IoctlReal >(Arena* arena) {
  return Arena::CreateMessageInternal< ::IoctlReal >(arena);
}
template<> PROTOBUF_NOINLINE ::IfReqFlags* Arena::CreateMaybeMessage< ::IfReqFlags >(Arena* arena) {
  return Arena::CreateMessageInternal< ::IfReqFlags >(arena);
}
template<> PROTOBUF_NOINLINE ::In6_AliasReq_64* Arena::CreateMaybeMessage< ::In6_AliasReq_64 >(Arena* arena) {
  return Arena::CreateMessageInternal< ::In6_AliasReq_64 >(arena);
}
template<> PROTOBUF_NOINLINE ::In6AddrLifetime_64* Arena::CreateMaybeMessage< ::In6AddrLifetime_64 >(Arena* arena) {
  return Arena::CreateMessageInternal< ::In6AddrLifetime_64 >(arena);
}
template<> PROTOBUF_NOINLINE ::Packet* Arena::CreateMaybeMessage< ::Packet >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Packet >(arena);
}
template<> PROTOBUF_NOINLINE ::TcpPacket* Arena::CreateMaybeMessage< ::TcpPacket >(Arena* arena) {
  return Arena::CreateMessageInternal< ::TcpPacket >(arena);
}
template<> PROTOBUF_NOINLINE ::Tcp6Packet* Arena::CreateMaybeMessage< ::Tcp6Packet >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Tcp6Packet >(arena);
}
template<> PROTOBUF_NOINLINE ::Ip4Packet* Arena::CreateMaybeMessage< ::Ip4Packet >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Ip4Packet >(arena);
}
template<> PROTOBUF_NOINLINE ::Ip6Packet* Arena::CreateMaybeMessage< ::Ip6Packet >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Ip6Packet >(arena);
}
template<> PROTOBUF_NOINLINE ::Ip6Ext* Arena::CreateMaybeMessage< ::Ip6Ext >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Ip6Ext >(arena);
}
template<> PROTOBUF_NOINLINE ::Ip6RtHdr* Arena::CreateMaybeMessage< ::Ip6RtHdr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Ip6RtHdr >(arena);
}
template<> PROTOBUF_NOINLINE ::Ip6Rt0Hdr* Arena::CreateMaybeMessage< ::Ip6Rt0Hdr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Ip6Rt0Hdr >(arena);
}
template<> PROTOBUF_NOINLINE ::Ip6FragHdr* Arena::CreateMaybeMessage< ::Ip6FragHdr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Ip6FragHdr >(arena);
}
template<> PROTOBUF_NOINLINE ::Icmp6Hdr* Arena::CreateMaybeMessage< ::Icmp6Hdr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Icmp6Hdr >(arena);
}
template<> PROTOBUF_NOINLINE ::TcpHdr* Arena::CreateMaybeMessage< ::TcpHdr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::TcpHdr >(arena);
}
template<> PROTOBUF_NOINLINE ::IpHdr* Arena::CreateMaybeMessage< ::IpHdr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::IpHdr >(arena);
}
template<> PROTOBUF_NOINLINE ::Ip6Hdr* Arena::CreateMaybeMessage< ::Ip6Hdr >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Ip6Hdr >(arena);
}
template<> PROTOBUF_NOINLINE ::Ip6Hdrctl* Arena::CreateMaybeMessage< ::Ip6Hdrctl >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Ip6Hdrctl >(arena);
}
template<> PROTOBUF_NOINLINE ::Key* Arena::CreateMaybeMessage< ::Key >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Key >(arena);
}
template<> PROTOBUF_NOINLINE ::Ioctl* Arena::CreateMaybeMessage< ::Ioctl >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Ioctl >(arena);
}
template<> PROTOBUF_NOINLINE ::SetSocketOpt* Arena::CreateMaybeMessage< ::SetSocketOpt >(Arena* arena) {
  return Arena::CreateMessageInternal< ::SetSocketOpt >(arena);
}
template<> PROTOBUF_NOINLINE ::GetSocketOpt* Arena::CreateMaybeMessage< ::GetSocketOpt >(Arena* arena) {
  return Arena::CreateMessageInternal< ::GetSocketOpt >(arena);
}
template<> PROTOBUF_NOINLINE ::Socket* Arena::CreateMaybeMessage< ::Socket >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Socket >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>

Coverage Report

Created: 2024-10-03 06:24