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

// source: xml.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_xml_2eproto

#define GOOGLE_PROTOBUF_INCLUDED_xml_2eproto

#include <limits>

#include <string>

#include <google/protobuf/port_def.inc>

#if PROTOBUF_VERSION < 3021000

#error This file was generated by a newer version of protoc which is

#error incompatible with your Protocol Buffer headers. Please update

#error your headers.

#endif

#if 3021007 < PROTOBUF_MIN_PROTOC_VERSION

#error This file was generated by an older version of protoc which is

#error incompatible with your Protocol Buffer headers. Please

#error regenerate this file with a newer version of protoc.

#endif

#include <google/protobuf/port_undef.inc>

#include <google/protobuf/io/coded_stream.h>

#include <google/protobuf/arena.h>

#include <google/protobuf/arenastring.h>

#include <google/protobuf/generated_message_util.h>

#include <google/protobuf/metadata_lite.h>

#include <google/protobuf/generated_message_reflection.h>

#include <google/protobuf/message.h>

#include <google/protobuf/repeated_field.h>  // IWYU pragma: export

#include <google/protobuf/extension_set.h>  // IWYU pragma: export

#include <google/protobuf/generated_enum_reflection.h>

#include <google/protobuf/unknown_field_set.h>

// @@protoc_insertion_point(includes)

#include <google/protobuf/port_def.inc>

#define PROTOBUF_INTERNAL_EXPORT_xml_2eproto

PROTOBUF_NAMESPACE_OPEN

namespace internal {

class AnyMetadata;

}  // namespace internal

PROTOBUF_NAMESPACE_CLOSE

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

struct TableStruct_xml_2eproto {

  static const uint32_t offsets[];

};

extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xml_2eproto;

namespace xmlProtoFuzzer {

class AttDef;

struct AttDefDefaultTypeInternal;

extern AttDefDefaultTypeInternal _AttDef_default_instance_;

class AttListDecl;

struct AttListDeclDefaultTypeInternal;

extern AttListDeclDefaultTypeInternal _AttListDecl_default_instance_;

class AttValue;

struct AttValueDefaultTypeInternal;

extern AttValueDefaultTypeInternal _AttValue_default_instance_;

class AttrListDecl;

struct AttrListDeclDefaultTypeInternal;

extern AttrListDeclDefaultTypeInternal _AttrListDecl_default_instance_;

class AttrType;

struct AttrTypeDefaultTypeInternal;

extern AttrTypeDefaultTypeInternal _AttrType_default_instance_;

class CData;

struct CDataDefaultTypeInternal;

extern CDataDefaultTypeInternal _CData_default_instance_;

class ConditionalSect;

struct ConditionalSectDefaultTypeInternal;

extern ConditionalSectDefaultTypeInternal _ConditionalSect_default_instance_;

class Content;

struct ContentDefaultTypeInternal;

extern ContentDefaultTypeInternal _Content_default_instance_;

class DefaultDecl;

struct DefaultDeclDefaultTypeInternal;

extern DefaultDeclDefaultTypeInternal _DefaultDecl_default_instance_;

class DocTypeDecl;

struct DocTypeDeclDefaultTypeInternal;

extern DocTypeDeclDefaultTypeInternal _DocTypeDecl_default_instance_;

class Element;

struct ElementDefaultTypeInternal;

extern ElementDefaultTypeInternal _Element_default_instance_;

class ElementDecl;

struct ElementDeclDefaultTypeInternal;

extern ElementDeclDefaultTypeInternal _ElementDecl_default_instance_;

class Encodings;

struct EncodingsDefaultTypeInternal;

extern EncodingsDefaultTypeInternal _Encodings_default_instance_;

class EntityDecl;

struct EntityDeclDefaultTypeInternal;

extern EntityDeclDefaultTypeInternal _EntityDecl_default_instance_;

class EntityDef;

struct EntityDefDefaultTypeInternal;

extern EntityDefDefaultTypeInternal _EntityDef_default_instance_;

class EntityValue;

struct EntityValueDefaultTypeInternal;

extern EntityValueDefaultTypeInternal _EntityValue_default_instance_;

class EnumeratedType;

struct EnumeratedTypeDefaultTypeInternal;

extern EnumeratedTypeDefaultTypeInternal _EnumeratedType_default_instance_;

class ExtSubsetDecl;

struct ExtSubsetDeclDefaultTypeInternal;

extern ExtSubsetDeclDefaultTypeInternal _ExtSubsetDecl_default_instance_;

class ExternalId;

struct ExternalIdDefaultTypeInternal;

extern ExternalIdDefaultTypeInternal _ExternalId_default_instance_;

class KeyValue;

struct KeyValueDefaultTypeInternal;

extern KeyValueDefaultTypeInternal _KeyValue_default_instance_;

class MarkupDecl;

struct MarkupDeclDefaultTypeInternal;

extern MarkupDeclDefaultTypeInternal _MarkupDecl_default_instance_;

class Misc;

struct MiscDefaultTypeInternal;

extern MiscDefaultTypeInternal _Misc_default_instance_;

class NDataDecl;

struct NDataDeclDefaultTypeInternal;

extern NDataDeclDefaultTypeInternal _NDataDecl_default_instance_;

class NotationDecl;

struct NotationDeclDefaultTypeInternal;

extern NotationDeclDefaultTypeInternal _NotationDecl_default_instance_;

class OneExtSubsetDecl;

struct OneExtSubsetDeclDefaultTypeInternal;

extern OneExtSubsetDeclDefaultTypeInternal _OneExtSubsetDecl_default_instance_;

class PEDef;

struct PEDefDefaultTypeInternal;

extern PEDefDefaultTypeInternal _PEDef_default_instance_;

class PEReference;

struct PEReferenceDefaultTypeInternal;

extern PEReferenceDefaultTypeInternal _PEReference_default_instance_;

class ProcessingInstruction;

struct ProcessingInstructionDefaultTypeInternal;

extern ProcessingInstructionDefaultTypeInternal _ProcessingInstruction_default_instance_;

class Prolog;

struct PrologDefaultTypeInternal;

extern PrologDefaultTypeInternal _Prolog_default_instance_;

class VersionNum;

struct VersionNumDefaultTypeInternal;

extern VersionNumDefaultTypeInternal _VersionNum_default_instance_;

class XmlDeclaration;

struct XmlDeclarationDefaultTypeInternal;

extern XmlDeclarationDefaultTypeInternal _XmlDeclaration_default_instance_;

class XmlDocument;

struct XmlDocumentDefaultTypeInternal;

extern XmlDocumentDefaultTypeInternal _XmlDocument_default_instance_;

}  // namespace xmlProtoFuzzer

PROTOBUF_NAMESPACE_OPEN

template<> ::xmlProtoFuzzer::AttDef* Arena::CreateMaybeMessage<::xmlProtoFuzzer::AttDef>(Arena*);

template<> ::xmlProtoFuzzer::AttListDecl* Arena::CreateMaybeMessage<::xmlProtoFuzzer::AttListDecl>(Arena*);

template<> ::xmlProtoFuzzer::AttValue* Arena::CreateMaybeMessage<::xmlProtoFuzzer::AttValue>(Arena*);

template<> ::xmlProtoFuzzer::AttrListDecl* Arena::CreateMaybeMessage<::xmlProtoFuzzer::AttrListDecl>(Arena*);

template<> ::xmlProtoFuzzer::AttrType* Arena::CreateMaybeMessage<::xmlProtoFuzzer::AttrType>(Arena*);

template<> ::xmlProtoFuzzer::CData* Arena::CreateMaybeMessage<::xmlProtoFuzzer::CData>(Arena*);

template<> ::xmlProtoFuzzer::ConditionalSect* Arena::CreateMaybeMessage<::xmlProtoFuzzer::ConditionalSect>(Arena*);

template<> ::xmlProtoFuzzer::Content* Arena::CreateMaybeMessage<::xmlProtoFuzzer::Content>(Arena*);

template<> ::xmlProtoFuzzer::DefaultDecl* Arena::CreateMaybeMessage<::xmlProtoFuzzer::DefaultDecl>(Arena*);

template<> ::xmlProtoFuzzer::DocTypeDecl* Arena::CreateMaybeMessage<::xmlProtoFuzzer::DocTypeDecl>(Arena*);

template<> ::xmlProtoFuzzer::Element* Arena::CreateMaybeMessage<::xmlProtoFuzzer::Element>(Arena*);

template<> ::xmlProtoFuzzer::ElementDecl* Arena::CreateMaybeMessage<::xmlProtoFuzzer::ElementDecl>(Arena*);

template<> ::xmlProtoFuzzer::Encodings* Arena::CreateMaybeMessage<::xmlProtoFuzzer::Encodings>(Arena*);

template<> ::xmlProtoFuzzer::EntityDecl* Arena::CreateMaybeMessage<::xmlProtoFuzzer::EntityDecl>(Arena*);

template<> ::xmlProtoFuzzer::EntityDef* Arena::CreateMaybeMessage<::xmlProtoFuzzer::EntityDef>(Arena*);

template<> ::xmlProtoFuzzer::EntityValue* Arena::CreateMaybeMessage<::xmlProtoFuzzer::EntityValue>(Arena*);

template<> ::xmlProtoFuzzer::EnumeratedType* Arena::CreateMaybeMessage<::xmlProtoFuzzer::EnumeratedType>(Arena*);

template<> ::xmlProtoFuzzer::ExtSubsetDecl* Arena::CreateMaybeMessage<::xmlProtoFuzzer::ExtSubsetDecl>(Arena*);

template<> ::xmlProtoFuzzer::ExternalId* Arena::CreateMaybeMessage<::xmlProtoFuzzer::ExternalId>(Arena*);

template<> ::xmlProtoFuzzer::KeyValue* Arena::CreateMaybeMessage<::xmlProtoFuzzer::KeyValue>(Arena*);

template<> ::xmlProtoFuzzer::MarkupDecl* Arena::CreateMaybeMessage<::xmlProtoFuzzer::MarkupDecl>(Arena*);

template<> ::xmlProtoFuzzer::Misc* Arena::CreateMaybeMessage<::xmlProtoFuzzer::Misc>(Arena*);

template<> ::xmlProtoFuzzer::NDataDecl* Arena::CreateMaybeMessage<::xmlProtoFuzzer::NDataDecl>(Arena*);

template<> ::xmlProtoFuzzer::NotationDecl* Arena::CreateMaybeMessage<::xmlProtoFuzzer::NotationDecl>(Arena*);

template<> ::xmlProtoFuzzer::OneExtSubsetDecl* Arena::CreateMaybeMessage<::xmlProtoFuzzer::OneExtSubsetDecl>(Arena*);

template<> ::xmlProtoFuzzer::PEDef* Arena::CreateMaybeMessage<::xmlProtoFuzzer::PEDef>(Arena*);

template<> ::xmlProtoFuzzer::PEReference* Arena::CreateMaybeMessage<::xmlProtoFuzzer::PEReference>(Arena*);

template<> ::xmlProtoFuzzer::ProcessingInstruction* Arena::CreateMaybeMessage<::xmlProtoFuzzer::ProcessingInstruction>(Arena*);

template<> ::xmlProtoFuzzer::Prolog* Arena::CreateMaybeMessage<::xmlProtoFuzzer::Prolog>(Arena*);

template<> ::xmlProtoFuzzer::VersionNum* Arena::CreateMaybeMessage<::xmlProtoFuzzer::VersionNum>(Arena*);

template<> ::xmlProtoFuzzer::XmlDeclaration* Arena::CreateMaybeMessage<::xmlProtoFuzzer::XmlDeclaration>(Arena*);

template<> ::xmlProtoFuzzer::XmlDocument* Arena::CreateMaybeMessage<::xmlProtoFuzzer::XmlDocument>(Arena*);

PROTOBUF_NAMESPACE_CLOSE

namespace xmlProtoFuzzer {

enum ElementDecl_ContentSpec : int {

  ElementDecl_ContentSpec_EMPTY = 0,

  ElementDecl_ContentSpec_ANY = 1,

  ElementDecl_ContentSpec_FUZZ = 2,

  ElementDecl_ContentSpec_MIXED = 3,

  ElementDecl_ContentSpec_CHILDREN = 4,

  ElementDecl_ContentSpec_ElementDecl_ContentSpec_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  ElementDecl_ContentSpec_ElementDecl_ContentSpec_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool ElementDecl_ContentSpec_IsValid(int value);

constexpr ElementDecl_ContentSpec ElementDecl_ContentSpec_ContentSpec_MIN = ElementDecl_ContentSpec_EMPTY;

constexpr ElementDecl_ContentSpec ElementDecl_ContentSpec_ContentSpec_MAX = ElementDecl_ContentSpec_CHILDREN;

constexpr int ElementDecl_ContentSpec_ContentSpec_ARRAYSIZE = ElementDecl_ContentSpec_ContentSpec_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function ElementDecl_ContentSpec_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    ElementDecl_ContentSpec_descriptor(), enum_t_value);

}

inline bool ElementDecl_ContentSpec_Parse(

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

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

    ElementDecl_ContentSpec_descriptor(), name, value);

}

enum AttrType_Type : int {

  AttrType_Type_CDATA = 0,

  AttrType_Type_ID = 1,

  AttrType_Type_IDREF = 2,

  AttrType_Type_IDREFS = 3,

  AttrType_Type_ENTITY = 4,

  AttrType_Type_ENTITIES = 5,

  AttrType_Type_NMTOKEN = 6,

  AttrType_Type_NMTOKENS = 7,

  AttrType_Type_AttrType_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  AttrType_Type_AttrType_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool AttrType_Type_IsValid(int value);

constexpr AttrType_Type AttrType_Type_Type_MIN = AttrType_Type_CDATA;

constexpr AttrType_Type AttrType_Type_Type_MAX = AttrType_Type_NMTOKENS;

constexpr int AttrType_Type_Type_ARRAYSIZE = AttrType_Type_Type_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function AttrType_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    AttrType_Type_descriptor(), enum_t_value);

}

inline bool AttrType_Type_Parse(

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

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

    AttrType_Type_descriptor(), name, value);

}

enum ExternalId_Type : int {

  ExternalId_Type_SYSTEM = 0,

  ExternalId_Type_PUBLIC = 1,

  ExternalId_Type_FUZZ = 2,

  ExternalId_Type_ExternalId_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  ExternalId_Type_ExternalId_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool ExternalId_Type_IsValid(int value);

constexpr ExternalId_Type ExternalId_Type_Type_MIN = ExternalId_Type_SYSTEM;

constexpr ExternalId_Type ExternalId_Type_Type_MAX = ExternalId_Type_FUZZ;

constexpr int ExternalId_Type_Type_ARRAYSIZE = ExternalId_Type_Type_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function ExternalId_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    ExternalId_Type_descriptor(), enum_t_value);

}

inline bool ExternalId_Type_Parse(

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

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

    ExternalId_Type_descriptor(), name, value);

}

enum AttValue_Type : int {

  AttValue_Type_ENTITY = 0,

  AttValue_Type_CHAR = 1,

  AttValue_Type_FUZZ = 2,

  AttValue_Type_AttValue_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  AttValue_Type_AttValue_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool AttValue_Type_IsValid(int value);

constexpr AttValue_Type AttValue_Type_Type_MIN = AttValue_Type_ENTITY;

constexpr AttValue_Type AttValue_Type_Type_MAX = AttValue_Type_FUZZ;

constexpr int AttValue_Type_Type_ARRAYSIZE = AttValue_Type_Type_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function AttValue_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    AttValue_Type_descriptor(), enum_t_value);

}

inline bool AttValue_Type_Parse(

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

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

    AttValue_Type_descriptor(), name, value);

}

enum DefaultDecl_Type : int {

  DefaultDecl_Type_REQUIRED = 0,

  DefaultDecl_Type_IMPLIED = 1,

  DefaultDecl_Type_FIXED = 2,

  DefaultDecl_Type_FUZZ = 3,

  DefaultDecl_Type_DefaultDecl_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  DefaultDecl_Type_DefaultDecl_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool DefaultDecl_Type_IsValid(int value);

constexpr DefaultDecl_Type DefaultDecl_Type_Type_MIN = DefaultDecl_Type_REQUIRED;

constexpr DefaultDecl_Type DefaultDecl_Type_Type_MAX = DefaultDecl_Type_FUZZ;

constexpr int DefaultDecl_Type_Type_ARRAYSIZE = DefaultDecl_Type_Type_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function DefaultDecl_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    DefaultDecl_Type_descriptor(), enum_t_value);

}

inline bool DefaultDecl_Type_Parse(

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

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

    DefaultDecl_Type_descriptor(), name, value);

}

enum AttDef_Type : int {

  AttDef_Type_CDATA = 0,

  AttDef_Type_ID = 1,

  AttDef_Type_IDREF = 2,

  AttDef_Type_IDREFS = 3,

  AttDef_Type_ENTITY = 4,

  AttDef_Type_ENTITIES = 5,

  AttDef_Type_NMTOKEN = 6,

  AttDef_Type_NMTOKENS = 7,

  AttDef_Type_FUZZ = 8,

  AttDef_Type_AttDef_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  AttDef_Type_AttDef_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool AttDef_Type_IsValid(int value);

constexpr AttDef_Type AttDef_Type_Type_MIN = AttDef_Type_CDATA;

constexpr AttDef_Type AttDef_Type_Type_MAX = AttDef_Type_FUZZ;

constexpr int AttDef_Type_Type_ARRAYSIZE = AttDef_Type_Type_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function AttDef_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    AttDef_Type_descriptor(), enum_t_value);

}

inline bool AttDef_Type_Parse(

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

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

    AttDef_Type_descriptor(), name, value);

}

enum EntityValue_Type : int {

  EntityValue_Type_ENTITY = 0,

  EntityValue_Type_CHAR = 1,

  EntityValue_Type_PEREF = 2,

  EntityValue_Type_FUZZ = 3,

  EntityValue_Type_EntityValue_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  EntityValue_Type_EntityValue_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool EntityValue_Type_IsValid(int value);

constexpr EntityValue_Type EntityValue_Type_Type_MIN = EntityValue_Type_ENTITY;

constexpr EntityValue_Type EntityValue_Type_Type_MAX = EntityValue_Type_FUZZ;

constexpr int EntityValue_Type_Type_ARRAYSIZE = EntityValue_Type_Type_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function EntityValue_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    EntityValue_Type_descriptor(), enum_t_value);

}

inline bool EntityValue_Type_Parse(

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

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

    EntityValue_Type_descriptor(), name, value);

}

enum EntityDecl_Type : int {

  EntityDecl_Type_GEDECL = 0,

  EntityDecl_Type_PEDECL = 1,

  EntityDecl_Type_EntityDecl_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  EntityDecl_Type_EntityDecl_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool EntityDecl_Type_IsValid(int value);

constexpr EntityDecl_Type EntityDecl_Type_Type_MIN = EntityDecl_Type_GEDECL;

constexpr EntityDecl_Type EntityDecl_Type_Type_MAX = EntityDecl_Type_PEDECL;

constexpr int EntityDecl_Type_Type_ARRAYSIZE = EntityDecl_Type_Type_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function EntityDecl_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    EntityDecl_Type_descriptor(), enum_t_value);

}

inline bool EntityDecl_Type_Parse(

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

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

    EntityDecl_Type_descriptor(), name, value);

}

enum ConditionalSect_Type : int {

  ConditionalSect_Type_INCLUDE = 0,

  ConditionalSect_Type_IGNORE = 1,

  ConditionalSect_Type_FUZZ = 2,

  ConditionalSect_Type_ConditionalSect_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  ConditionalSect_Type_ConditionalSect_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool ConditionalSect_Type_IsValid(int value);

constexpr ConditionalSect_Type ConditionalSect_Type_Type_MIN = ConditionalSect_Type_INCLUDE;

constexpr ConditionalSect_Type ConditionalSect_Type_Type_MAX = ConditionalSect_Type_FUZZ;

constexpr int ConditionalSect_Type_Type_ARRAYSIZE = ConditionalSect_Type_Type_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function ConditionalSect_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    ConditionalSect_Type_descriptor(), enum_t_value);

}

inline bool ConditionalSect_Type_Parse(

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

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

    ConditionalSect_Type_descriptor(), name, value);

}

enum KeyValue_XmlNamespace : int {

  KeyValue_XmlNamespace_ATTRIBUTES = 0,

  KeyValue_XmlNamespace_BASE = 1,

  KeyValue_XmlNamespace_CATALOG = 2,

  KeyValue_XmlNamespace_ID = 3,

  KeyValue_XmlNamespace_LANG = 4,

  KeyValue_XmlNamespace_LINK = 5,

  KeyValue_XmlNamespace_SPACE = 6,

  KeyValue_XmlNamespace_SPECIAL = 7,

  KeyValue_XmlNamespace_TEST = 8,

  KeyValue_XmlNamespace_FUZZ = 9,

  KeyValue_XmlNamespace_KeyValue_XmlNamespace_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  KeyValue_XmlNamespace_KeyValue_XmlNamespace_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool KeyValue_XmlNamespace_IsValid(int value);

constexpr KeyValue_XmlNamespace KeyValue_XmlNamespace_XmlNamespace_MIN = KeyValue_XmlNamespace_ATTRIBUTES;

constexpr KeyValue_XmlNamespace KeyValue_XmlNamespace_XmlNamespace_MAX = KeyValue_XmlNamespace_FUZZ;

constexpr int KeyValue_XmlNamespace_XmlNamespace_ARRAYSIZE = KeyValue_XmlNamespace_XmlNamespace_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function KeyValue_XmlNamespace_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    KeyValue_XmlNamespace_descriptor(), enum_t_value);

}

inline bool KeyValue_XmlNamespace_Parse(

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

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

    KeyValue_XmlNamespace_descriptor(), name, value);

}

enum Element_Type : int {

  Element_Type_PREDEFINED = 0,

  Element_Type_FUZZ = 1,

  Element_Type_Element_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  Element_Type_Element_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool Element_Type_IsValid(int value);

constexpr Element_Type Element_Type_Type_MIN = Element_Type_PREDEFINED;

constexpr Element_Type Element_Type_Type_MAX = Element_Type_FUZZ;

constexpr int Element_Type_Type_ARRAYSIZE = Element_Type_Type_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function Element_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    Element_Type_descriptor(), enum_t_value);

}

inline bool Element_Type_Parse(

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

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

    Element_Type_descriptor(), name, value);

}

enum Element_Id : int {

  Element_Id_XIINCLUDE = 0,

  Element_Id_XIFALLBACK = 1,

  Element_Id_XIHREF = 2,

  Element_Id_XIPARSE = 3,

  Element_Id_XIXPOINTER = 4,

  Element_Id_XIENCODING = 5,

  Element_Id_XIACCEPT = 6,

  Element_Id_XIACCEPTLANG = 7,

  Element_Id_Element_Id_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  Element_Id_Element_Id_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool Element_Id_IsValid(int value);

constexpr Element_Id Element_Id_Id_MIN = Element_Id_XIINCLUDE;

constexpr Element_Id Element_Id_Id_MAX = Element_Id_XIACCEPTLANG;

constexpr int Element_Id_Id_ARRAYSIZE = Element_Id_Id_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function Element_Id_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    Element_Id_descriptor(), enum_t_value);

}

inline bool Element_Id_Parse(

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

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

    Element_Id_descriptor(), name, value);

}

enum VersionNum_Type : int {

  VersionNum_Type_STANDARD = 0,

  VersionNum_Type_FUZZ = 1,

  VersionNum_Type_VersionNum_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  VersionNum_Type_VersionNum_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool VersionNum_Type_IsValid(int value);

constexpr VersionNum_Type VersionNum_Type_Type_MIN = VersionNum_Type_STANDARD;

constexpr VersionNum_Type VersionNum_Type_Type_MAX = VersionNum_Type_FUZZ;

constexpr int VersionNum_Type_Type_ARRAYSIZE = VersionNum_Type_Type_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function VersionNum_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    VersionNum_Type_descriptor(), enum_t_value);

}

inline bool VersionNum_Type_Parse(

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

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

    VersionNum_Type_descriptor(), name, value);

}

enum Encodings_Enc : int {

  Encodings_Enc_BIG5 = 0,

  Encodings_Enc_EUCJP = 1,

  Encodings_Enc_EUCKR = 2,

  Encodings_Enc_GB18030 = 3,

  Encodings_Enc_ISO2022JP = 4,

  Encodings_Enc_ISO2022KR = 5,

  Encodings_Enc_ISO88591 = 6,

  Encodings_Enc_ISO88592 = 7,

  Encodings_Enc_ISO88593 = 8,

  Encodings_Enc_ISO88594 = 9,

  Encodings_Enc_ISO88595 = 10,

  Encodings_Enc_ISO88596 = 11,

  Encodings_Enc_ISO88597 = 12,

  Encodings_Enc_ISO88598 = 13,

  Encodings_Enc_ISO88599 = 14,

  Encodings_Enc_SHIFTJIS = 15,

  Encodings_Enc_TIS620 = 16,

  Encodings_Enc_USASCII = 17,

  Encodings_Enc_UTF8 = 18,

  Encodings_Enc_UTF16 = 19,

  Encodings_Enc_UTF16BE = 20,

  Encodings_Enc_UTF16LE = 21,

  Encodings_Enc_WINDOWS31J = 22,

  Encodings_Enc_WINDOWS1255 = 23,

  Encodings_Enc_WINDOWS1256 = 24,

  Encodings_Enc_FUZZ = 25,

  Encodings_Enc_Encodings_Enc_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  Encodings_Enc_Encodings_Enc_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool Encodings_Enc_IsValid(int value);

constexpr Encodings_Enc Encodings_Enc_Enc_MIN = Encodings_Enc_BIG5;

constexpr Encodings_Enc Encodings_Enc_Enc_MAX = Encodings_Enc_FUZZ;

constexpr int Encodings_Enc_Enc_ARRAYSIZE = Encodings_Enc_Enc_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function Encodings_Enc_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    Encodings_Enc_descriptor(), enum_t_value);

}

inline bool Encodings_Enc_Parse(

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

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

    Encodings_Enc_descriptor(), name, value);

}

enum XmlDeclaration_Standalone : int {

  XmlDeclaration_Standalone_YES = 0,

  XmlDeclaration_Standalone_NO = 1,

  XmlDeclaration_Standalone_XmlDeclaration_Standalone_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),

  XmlDeclaration_Standalone_XmlDeclaration_Standalone_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()

};

bool XmlDeclaration_Standalone_IsValid(int value);

constexpr XmlDeclaration_Standalone XmlDeclaration_Standalone_Standalone_MIN = XmlDeclaration_Standalone_YES;

constexpr XmlDeclaration_Standalone XmlDeclaration_Standalone_Standalone_MAX = XmlDeclaration_Standalone_NO;

constexpr int XmlDeclaration_Standalone_Standalone_ARRAYSIZE = XmlDeclaration_Standalone_Standalone_MAX + 1;

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

template<typename T>

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

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

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

    "Incorrect type passed to function XmlDeclaration_Standalone_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    XmlDeclaration_Standalone_descriptor(), enum_t_value);

}

inline bool XmlDeclaration_Standalone_Parse(

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

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

    XmlDeclaration_Standalone_descriptor(), name, value);

}

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

class Misc final :

    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xmlProtoFuzzer.Misc) */ {

 public:

  inline Misc() : Misc(nullptr) {}

  ~Misc() override;

  explicit PROTOBUF_CONSTEXPR Misc(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Misc(const Misc& from);

  Misc(Misc&& from) noexcept

    : Misc() {

    *this = ::std::move(from);

  }

  inline Misc& operator=(const Misc& from) {

    CopyFrom(from);

    return *this;

  }

  inline Misc& operator=(Misc&& from) noexcept {

    if (this == &from) return *this;

    if (GetOwningArena() == from.GetOwningArena()

  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE

        && GetOwningArena() != nullptr

  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE

    ) {

      InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {

    return GetDescriptor();

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {

    return default_instance().GetMetadata().descriptor;

  }

  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {

    return default_instance().GetMetadata().reflection;

  }

  static const Misc& default_instance() {

    return *internal_default_instance();

  }

  enum MiscOneofCase {

    kComment = 1,

    kInst = 2,

    MISC_ONEOF_NOT_SET = 0,

  };

  static inline const Misc* internal_default_instance() {

    return reinterpret_cast<const Misc*>(

               &_Misc_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    0;

  friend void swap(Misc& a, Misc& b) {

    a.Swap(&b);

  }

  inline void Swap(Misc* other) {

    if (other == this) return;

  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() != nullptr &&

        GetOwningArena() == other->GetOwningArena()) {

   #else  // PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() == other->GetOwningArena()) {

  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP

      InternalSwap(other);

    } else {

      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);

    }

  }

  void UnsafeArenaSwap(Misc* other) {

    if (other == this) return;

    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());

    InternalSwap(other);

  }

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

  Misc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {

    return CreateMaybeMessage<Misc>(arena);

  }

  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;

  void CopyFrom(const Misc& from);

  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;

  void MergeFrom( const Misc& from) {

    Misc::MergeImpl(*this, from);

  }

  private:

  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);

  public:

  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;

  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;

  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;

  uint8_t* _InternalSerialize(

      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;

  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:

  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);

  void SharedDtor();

  void SetCachedSize(int size) const final;

  void InternalSwap(Misc* other);

  private:

  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;

  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {

    return "xmlProtoFuzzer.Misc";

  }

  protected:

  explicit Misc(::PROTOBUF_NAMESPACE_ID::Arena* arena,

                       bool is_message_owned = false);

  public:

  static const ClassData _class_data_;

  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {

    kCommentFieldNumber = 1,

    kInstFieldNumber = 2,

  };

  // string comment = 1;

  bool has_comment() const;

  private:

  bool _internal_has_comment() const;

  public:

  void clear_comment();

  const std::string& comment() const;

  template <typename ArgT0 = const std::string&, typename... ArgT>

  void set_comment(ArgT0&& arg0, ArgT... args);

  std::string* mutable_comment();

  PROTOBUF_NODISCARD std::string* release_comment();

  void set_allocated_comment(std::string* comment);

  private:

  const std::string& _internal_comment() const;

  inline PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const std::string& value);

  std::string* _internal_mutable_comment();

  public:

  // .xmlProtoFuzzer.ProcessingInstruction inst = 2;

  bool has_inst() const;

  private:

  bool _internal_has_inst() const;

  public:

  void clear_inst();

  const ::xmlProtoFuzzer::ProcessingInstruction& inst() const;

  PROTOBUF_NODISCARD ::xmlProtoFuzzer::ProcessingInstruction* release_inst();

  ::xmlProtoFuzzer::ProcessingInstruction* mutable_inst();

  void set_allocated_inst(::xmlProtoFuzzer::ProcessingInstruction* inst);

  private:

  const ::xmlProtoFuzzer::ProcessingInstruction& _internal_inst() const;

  ::xmlProtoFuzzer::ProcessingInstruction* _internal_mutable_inst();

  public:

  void unsafe_arena_set_allocated_inst(

      ::xmlProtoFuzzer::ProcessingInstruction* inst);

  ::xmlProtoFuzzer::ProcessingInstruction* unsafe_arena_release_inst();

  void clear_misc_oneof();

  MiscOneofCase misc_oneof_case() const;

  // @@protoc_insertion_point(class_scope:xmlProtoFuzzer.Misc)

 private:

  class _Internal;

  void set_has_comment();

  void set_has_inst();

  inline bool has_misc_oneof() const;

  inline void clear_has_misc_oneof();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;

  typedef void InternalArenaConstructable_;

  typedef void DestructorSkippable_;

  struct Impl_ {

    union MiscOneofUnion {

      constexpr MiscOneofUnion() : _constinit_{} {}

        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;

      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_;

      ::xmlProtoFuzzer::ProcessingInstruction* inst_;

    } misc_oneof_;

    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;

    uint32_t _oneof_case_[1];

  };

  union { Impl_ _impl_; };

  friend struct ::TableStruct_xml_2eproto;

};

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

class PEReference final :

    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xmlProtoFuzzer.PEReference) */ {

 public:

  inline PEReference() : PEReference(nullptr) {}

  ~PEReference() override;

  explicit PROTOBUF_CONSTEXPR PEReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PEReference(const PEReference& from);

  PEReference(PEReference&& from) noexcept

    : PEReference() {

    *this = ::std::move(from);

  }

  inline PEReference& operator=(const PEReference& from) {

    CopyFrom(from);

    return *this;

  }

  inline PEReference& operator=(PEReference&& from) noexcept {

    if (this == &from) return *this;

    if (GetOwningArena() == from.GetOwningArena()

  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE

        && GetOwningArena() != nullptr

  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE

    ) {

      InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {

    return GetDescriptor();

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {

    return default_instance().GetMetadata().descriptor;

  }

  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {

    return default_instance().GetMetadata().reflection;

  }

  static const PEReference& default_instance() {

    return *internal_default_instance();

  }

  static inline const PEReference* internal_default_instance() {

    return reinterpret_cast<const PEReference*>(

               &_PEReference_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    1;

  friend void swap(PEReference& a, PEReference& b) {

    a.Swap(&b);

  }

  inline void Swap(PEReference* other) {

    if (other == this) return;

  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() != nullptr &&

        GetOwningArena() == other->GetOwningArena()) {

   #else  // PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() == other->GetOwningArena()) {

  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP

      InternalSwap(other);

    } else {

      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);

    }

  }

  void UnsafeArenaSwap(PEReference* other) {

    if (other == this) return;

    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());

    InternalSwap(other);

  }

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

  PEReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {

    return CreateMaybeMessage<PEReference>(arena);

  }

  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;

  void CopyFrom(const PEReference& from);

  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;

  void MergeFrom( const PEReference& from) {

    PEReference::MergeImpl(*this, from);

  }

  private:

  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);

  public:

  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;

  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;

  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;

  uint8_t* _InternalSerialize(

      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;

  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:

  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);

  void SharedDtor();

  void SetCachedSize(int size) const final;

  void InternalSwap(PEReference* other);

  private:

  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;

  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {

    return "xmlProtoFuzzer.PEReference";

  }

  protected:

  explicit PEReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,

                       bool is_message_owned = false);

  public:

  static const ClassData _class_data_;

  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {

    kNameFieldNumber = 1,

  };

  // string name = 1;

  void clear_name();

  const std::string& name() const;

  template <typename ArgT0 = const std::string&, typename... ArgT>

  void set_name(ArgT0&& arg0, ArgT... args);

  std::string* mutable_name();

  PROTOBUF_NODISCARD std::string* release_name();

  void set_allocated_name(std::string* name);

  private:

  const std::string& _internal_name() const;

  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);

  std::string* _internal_mutable_name();

  public:

  // @@protoc_insertion_point(class_scope:xmlProtoFuzzer.PEReference)

 private:

  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;

  typedef void InternalArenaConstructable_;

  typedef void DestructorSkippable_;

  struct Impl_ {

    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;

    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;

  };

  union { Impl_ _impl_; };

  friend struct ::TableStruct_xml_2eproto;

};

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

class ElementDecl final :

    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xmlProtoFuzzer.ElementDecl) */ {

 public:

  inline ElementDecl() : ElementDecl(nullptr) {}

  ~ElementDecl() override;

  explicit PROTOBUF_CONSTEXPR ElementDecl(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ElementDecl(const ElementDecl& from);

  ElementDecl(ElementDecl&& from) noexcept

    : ElementDecl() {

    *this = ::std::move(from);

  }

  inline ElementDecl& operator=(const ElementDecl& from) {

    CopyFrom(from);

    return *this;

  }

  inline ElementDecl& operator=(ElementDecl&& from) noexcept {

    if (this == &from) return *this;

    if (GetOwningArena() == from.GetOwningArena()

  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE

        && GetOwningArena() != nullptr

  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE

    ) {

      InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {

    return GetDescriptor();

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {

    return default_instance().GetMetadata().descriptor;

  }

  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {

    return default_instance().GetMetadata().reflection;

  }

  static const ElementDecl& default_instance() {

    return *internal_default_instance();

  }

  static inline const ElementDecl* internal_default_instance() {

    return reinterpret_cast<const ElementDecl*>(

               &_ElementDecl_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    2;

  friend void swap(ElementDecl& a, ElementDecl& b) {

    a.Swap(&b);

  }

  inline void Swap(ElementDecl* other) {

    if (other == this) return;

  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() != nullptr &&

        GetOwningArena() == other->GetOwningArena()) {

   #else  // PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() == other->GetOwningArena()) {

  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP

      InternalSwap(other);

    } else {

      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);

    }

  }

  void UnsafeArenaSwap(ElementDecl* other) {

    if (other == this) return;

    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());

    InternalSwap(other);

  }

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

  ElementDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {

    return CreateMaybeMessage<ElementDecl>(arena);

  }

  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;

  void CopyFrom(const ElementDecl& from);

  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;

  void MergeFrom( const ElementDecl& from) {

    ElementDecl::MergeImpl(*this, from);

  }

  private:

  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);

  public:

  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;

  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;

  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;

  uint8_t* _InternalSerialize(

      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;

  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:

  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);

  void SharedDtor();