/src/libprotobuf-mutator/build/examples/xml/xml.pb.h

Source
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: xml.proto
// Protobuf C++ Version: 5.29.3

#ifndef xml_2eproto_2epb_2eh
#define xml_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 5029003
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/unknown_field_set.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_xml_2eproto

namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct TableStruct_xml_2eproto {
  static const ::uint32_t offsets[];
};
extern const ::google::protobuf::internal::DescriptorTable
    descriptor_table_xml_2eproto;
namespace protobuf_mutator {
namespace xml {
class Attribute;
struct AttributeDefaultTypeInternal;
extern AttributeDefaultTypeInternal _Attribute_default_instance_;
class Content;
struct ContentDefaultTypeInternal;
extern ContentDefaultTypeInternal _Content_default_instance_;
class DoctypeDecl;
struct DoctypeDeclDefaultTypeInternal;
extern DoctypeDeclDefaultTypeInternal _DoctypeDecl_default_instance_;
class Document;
struct DocumentDefaultTypeInternal;
extern DocumentDefaultTypeInternal _Document_default_instance_;
class Element;
struct ElementDefaultTypeInternal;
extern ElementDefaultTypeInternal _Element_default_instance_;
class Input;
struct InputDefaultTypeInternal;
extern InputDefaultTypeInternal _Input_default_instance_;
class Misk;
struct MiskDefaultTypeInternal;
extern MiskDefaultTypeInternal _Misk_default_instance_;
class Pi;
struct PiDefaultTypeInternal;
extern PiDefaultTypeInternal _Pi_default_instance_;
class Reference;
struct ReferenceDefaultTypeInternal;
extern ReferenceDefaultTypeInternal _Reference_default_instance_;
class Tag;
struct TagDefaultTypeInternal;
extern TagDefaultTypeInternal _Tag_default_instance_;
}  // namespace xml
}  // namespace protobuf_mutator
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google

namespace protobuf_mutator {
namespace xml {

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


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

class Reference final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:protobuf_mutator.xml.Reference) */ {
 public:
  inline Reference() : Reference(nullptr) {}
  ~Reference() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Reference* msg, std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Reference));
  }
#endif

  template <typename = void>
  explicit PROTOBUF_CONSTEXPR Reference(
      ::google::protobuf::internal::ConstantInitialized);

  inline Reference(const Reference& from) : Reference(nullptr, from) {}
  inline Reference(Reference&& from) noexcept
      : Reference(nullptr, std::move(from)) {}
  inline Reference& operator=(const Reference& from) {
    CopyFrom(from);
    return *this;
  }
  inline Reference& operator=(Reference&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Reference& default_instance() {
    return *internal_default_instance();
  }
  static inline const Reference* internal_default_instance() {
    return reinterpret_cast<const Reference*>(
        &_Reference_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(Reference& a, Reference& b) { a.Swap(&b); }
  inline void Swap(Reference* other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Reference* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Reference* New(::google::protobuf::Arena* arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Reference>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Reference& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Reference& from) { Reference::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Reference* other);
 private:
  template <typename T>
  friend ::absl::string_view(
      ::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "protobuf_mutator.xml.Reference"; }

 protected:
  explicit Reference(::google::protobuf::Arena* arena);
  Reference(::google::protobuf::Arena* arena, const Reference& from);
  Reference(::google::protobuf::Arena* arena, Reference&& from) noexcept
      : Reference(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;
  static void* PlacementNew_(const void*, void* mem,
                             ::google::protobuf::Arena* arena);
  static constexpr auto InternalNewImpl_();
  static const ::google::protobuf::internal::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNameFieldNumber = 1,
    kEntryFieldNumber = 2,
  };
  // optional string name = 1;
  bool has_name() const;
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  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:
  // optional bool entry = 2;
  bool has_entry() const;
  void clear_entry() ;
  bool entry() const;
  void set_entry(bool value);

  private:
  bool _internal_entry() const;
  void _internal_set_entry(bool value);

  public:
  // @@protoc_insertion_point(class_scope:protobuf_mutator.xml.Reference)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      43, 2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const Reference& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    bool entry_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xml_2eproto;
};
// -------------------------------------------------------------------

class Pi final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:protobuf_mutator.xml.Pi) */ {
 public:
  inline Pi() : Pi(nullptr) {}
  ~Pi() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Pi* msg, std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Pi));
  }
#endif

  template <typename = void>
  explicit PROTOBUF_CONSTEXPR Pi(
      ::google::protobuf::internal::ConstantInitialized);

  inline Pi(const Pi& from) : Pi(nullptr, from) {}
  inline Pi(Pi&& from) noexcept
      : Pi(nullptr, std::move(from)) {}
  inline Pi& operator=(const Pi& from) {
    CopyFrom(from);
    return *this;
  }
  inline Pi& operator=(Pi&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Pi& default_instance() {
    return *internal_default_instance();
  }
  static inline const Pi* internal_default_instance() {
    return reinterpret_cast<const Pi*>(
        &_Pi_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(Pi& a, Pi& b) { a.Swap(&b); }
  inline void Swap(Pi* other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Pi* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Pi* New(::google::protobuf::Arena* arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Pi>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Pi& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Pi& from) { Pi::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Pi* other);
 private:
  template <typename T>
  friend ::absl::string_view(
      ::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "protobuf_mutator.xml.Pi"; }

 protected:
  explicit Pi(::google::protobuf::Arena* arena);
  Pi(::google::protobuf::Arena* arena, const Pi& from);
  Pi(::google::protobuf::Arena* arena, Pi&& from) noexcept
      : Pi(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;
  static void* PlacementNew_(const void*, void* mem,
                             ::google::protobuf::Arena* arena);
  static constexpr auto InternalNewImpl_();
  static const ::google::protobuf::internal::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kTargetFieldNumber = 1,
    kDataFieldNumber = 2,
  };
  // optional string target = 1;
  bool has_target() const;
  void clear_target() ;
  const std::string& target() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_target(Arg_&& arg, Args_... args);
  std::string* mutable_target();
  PROTOBUF_NODISCARD std::string* release_target();
  void set_allocated_target(std::string* value);

  private:
  const std::string& _internal_target() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_target(
      const std::string& value);
  std::string* _internal_mutable_target();

  public:
  // optional string data = 2;
  bool has_data() const;
  void clear_data() ;
  const std::string& data() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_data(Arg_&& arg, Args_... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* value);

  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(
      const std::string& value);
  std::string* _internal_mutable_data();

  public:
  // @@protoc_insertion_point(class_scope:protobuf_mutator.xml.Pi)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      42, 2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const Pi& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr target_;
    ::google::protobuf::internal::ArenaStringPtr data_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xml_2eproto;
};
// -------------------------------------------------------------------

class Attribute final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:protobuf_mutator.xml.Attribute) */ {
 public:
  inline Attribute() : Attribute(nullptr) {}
  ~Attribute() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Attribute* msg, std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Attribute));
  }
#endif

  template <typename = void>
  explicit PROTOBUF_CONSTEXPR Attribute(
      ::google::protobuf::internal::ConstantInitialized);

  inline Attribute(const Attribute& from) : Attribute(nullptr, from) {}
  inline Attribute(Attribute&& from) noexcept
      : Attribute(nullptr, std::move(from)) {}
  inline Attribute& operator=(const Attribute& from) {
    CopyFrom(from);
    return *this;
  }
  inline Attribute& operator=(Attribute&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Attribute& default_instance() {
    return *internal_default_instance();
  }
  static inline const Attribute* internal_default_instance() {
    return reinterpret_cast<const Attribute*>(
        &_Attribute_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 8;
  friend void swap(Attribute& a, Attribute& b) { a.Swap(&b); }
  inline void Swap(Attribute* other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Attribute* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Attribute* New(::google::protobuf::Arena* arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Attribute>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Attribute& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Attribute& from) { Attribute::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Attribute* other);
 private:
  template <typename T>
  friend ::absl::string_view(
      ::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "protobuf_mutator.xml.Attribute"; }

 protected:
  explicit Attribute(::google::protobuf::Arena* arena);
  Attribute(::google::protobuf::Arena* arena, const Attribute& from);
  Attribute(::google::protobuf::Arena* arena, Attribute&& from) noexcept
      : Attribute(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;
  static void* PlacementNew_(const void*, void* mem,
                             ::google::protobuf::Arena* arena);
  static constexpr auto InternalNewImpl_();
  static const ::google::protobuf::internal::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNameFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // optional string name = 1;
  bool has_name() const;
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  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:
  // optional string value = 2;
  bool has_value() const;
  void clear_value() ;
  const std::string& value() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_value(Arg_&& arg, Args_... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);

  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(
      const std::string& value);
  std::string* _internal_mutable_value();

  public:
  // @@protoc_insertion_point(class_scope:protobuf_mutator.xml.Attribute)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      48, 2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const Attribute& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr value_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xml_2eproto;
};
// -------------------------------------------------------------------

class Tag final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:protobuf_mutator.xml.Tag) */ {
 public:
  inline Tag() : Tag(nullptr) {}
  ~Tag() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Tag* msg, std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Tag));
  }
#endif

  template <typename = void>
  explicit PROTOBUF_CONSTEXPR Tag(
      ::google::protobuf::internal::ConstantInitialized);

  inline Tag(const Tag& from) : Tag(nullptr, from) {}
  inline Tag(Tag&& from) noexcept
      : Tag(nullptr, std::move(from)) {}
  inline Tag& operator=(const Tag& from) {
    CopyFrom(from);
    return *this;
  }
  inline Tag& operator=(Tag&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Tag& default_instance() {
    return *internal_default_instance();
  }
  static inline const Tag* internal_default_instance() {
    return reinterpret_cast<const Tag*>(
        &_Tag_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(Tag& a, Tag& b) { a.Swap(&b); }
  inline void Swap(Tag* other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Tag* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Tag* New(::google::protobuf::Arena* arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Tag>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Tag& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Tag& from) { Tag::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Tag* other);
 private:
  template <typename T>
  friend ::absl::string_view(
      ::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "protobuf_mutator.xml.Tag"; }

 protected:
  explicit Tag(::google::protobuf::Arena* arena);
  Tag(::google::protobuf::Arena* arena, const Tag& from);
  Tag(::google::protobuf::Arena* arena, Tag&& from) noexcept
      : Tag(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;
  static void* PlacementNew_(const void*, void* mem,
                             ::google::protobuf::Arena* arena);
  static constexpr auto InternalNewImpl_();
  static const ::google::protobuf::internal::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kAttributeFieldNumber = 2,
    kNameFieldNumber = 1,
  };
  // repeated .protobuf_mutator.xml.Attribute attribute = 2;
  int attribute_size() const;
  private:
  int _internal_attribute_size() const;

  public:
  void clear_attribute() ;
  ::protobuf_mutator::xml::Attribute* mutable_attribute(int index);
  ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Attribute>* mutable_attribute();

  private:
  const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Attribute>& _internal_attribute() const;
  ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Attribute>* _internal_mutable_attribute();
  public:
  const ::protobuf_mutator::xml::Attribute& attribute(int index) const;
  ::protobuf_mutator::xml::Attribute* add_attribute();
  const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Attribute>& attribute() const;
  // optional string name = 1;
  bool has_name() const;
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  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:protobuf_mutator.xml.Tag)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      37, 2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const Tag& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::protobuf_mutator::xml::Attribute > attribute_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xml_2eproto;
};
// -------------------------------------------------------------------

class Misk final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:protobuf_mutator.xml.Misk) */ {
 public:
  inline Misk() : Misk(nullptr) {}
  ~Misk() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Misk* msg, std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Misk));
  }
#endif

  template <typename = void>
  explicit PROTOBUF_CONSTEXPR Misk(
      ::google::protobuf::internal::ConstantInitialized);

  inline Misk(const Misk& from) : Misk(nullptr, from) {}
  inline Misk(Misk&& from) noexcept
      : Misk(nullptr, std::move(from)) {}
  inline Misk& operator=(const Misk& from) {
    CopyFrom(from);
    return *this;
  }
  inline Misk& operator=(Misk&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Misk& default_instance() {
    return *internal_default_instance();
  }
  enum Case {
    kPi = 1,
    kComment = 2,
    __NOT_SET = 0,
  };
  static inline const Misk* internal_default_instance() {
    return reinterpret_cast<const Misk*>(
        &_Misk_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(Misk& a, Misk& b) { a.Swap(&b); }
  inline void Swap(Misk* other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Misk* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Misk* New(::google::protobuf::Arena* arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Misk>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Misk& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Misk& from) { Misk::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Misk* other);
 private:
  template <typename T>
  friend ::absl::string_view(
      ::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "protobuf_mutator.xml.Misk"; }

 protected:
  explicit Misk(::google::protobuf::Arena* arena);
  Misk(::google::protobuf::Arena* arena, const Misk& from);
  Misk(::google::protobuf::Arena* arena, Misk&& from) noexcept
      : Misk(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;
  static void* PlacementNew_(const void*, void* mem,
                             ::google::protobuf::Arena* arena);
  static constexpr auto InternalNewImpl_();
  static const ::google::protobuf::internal::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kPiFieldNumber = 1,
    kCommentFieldNumber = 2,
  };
  // .protobuf_mutator.xml.Pi pi = 1;
  bool has_pi() const;
  private:
  bool _internal_has_pi() const;

  public:
  void clear_pi() ;
  const ::protobuf_mutator::xml::Pi& pi() const;
  PROTOBUF_NODISCARD ::protobuf_mutator::xml::Pi* release_pi();
  ::protobuf_mutator::xml::Pi* mutable_pi();
  void set_allocated_pi(::protobuf_mutator::xml::Pi* value);
  void unsafe_arena_set_allocated_pi(::protobuf_mutator::xml::Pi* value);
  ::protobuf_mutator::xml::Pi* unsafe_arena_release_pi();

  private:
  const ::protobuf_mutator::xml::Pi& _internal_pi() const;
  ::protobuf_mutator::xml::Pi* _internal_mutable_pi();

  public:
  // string comment = 2;
  bool has_comment() const;
  void clear_comment() ;
  const std::string& comment() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_comment(Arg_&& arg, Args_... args);
  std::string* mutable_comment();
  PROTOBUF_NODISCARD std::string* release_comment();
  void set_allocated_comment(std::string* value);

  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:
  void clear__();
  Case __case() const;
  // @@protoc_insertion_point(class_scope:protobuf_mutator.xml.Misk)
 private:
  class _Internal;
  void set_has_pi();
  void set_has_comment();
  inline bool has__() const;
  inline void clear_has__();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 2, 1,
      41, 2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const Misk& from_msg);
    union Union {
      constexpr Union() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::protobuf_mutator::xml::Pi* pi_;
      ::google::protobuf::internal::ArenaStringPtr comment_;
    } __;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xml_2eproto;
};
// -------------------------------------------------------------------

class DoctypeDecl final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:protobuf_mutator.xml.DoctypeDecl) */ {
 public:
  inline DoctypeDecl() : DoctypeDecl(nullptr) {}
  ~DoctypeDecl() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(DoctypeDecl* msg, std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(DoctypeDecl));
  }
#endif

  template <typename = void>
  explicit PROTOBUF_CONSTEXPR DoctypeDecl(
      ::google::protobuf::internal::ConstantInitialized);

  inline DoctypeDecl(const DoctypeDecl& from) : DoctypeDecl(nullptr, from) {}
  inline DoctypeDecl(DoctypeDecl&& from) noexcept
      : DoctypeDecl(nullptr, std::move(from)) {}
  inline DoctypeDecl& operator=(const DoctypeDecl& from) {
    CopyFrom(from);
    return *this;
  }
  inline DoctypeDecl& operator=(DoctypeDecl&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DoctypeDecl& default_instance() {
    return *internal_default_instance();
  }
  static inline const DoctypeDecl* internal_default_instance() {
    return reinterpret_cast<const DoctypeDecl*>(
        &_DoctypeDecl_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(DoctypeDecl& a, DoctypeDecl& b) { a.Swap(&b); }
  inline void Swap(DoctypeDecl* other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DoctypeDecl* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  DoctypeDecl* New(::google::protobuf::Arena* arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<DoctypeDecl>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DoctypeDecl& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const DoctypeDecl& from) { DoctypeDecl::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(DoctypeDecl* other);
 private:
  template <typename T>
  friend ::absl::string_view(
      ::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "protobuf_mutator.xml.DoctypeDecl"; }

 protected:
  explicit DoctypeDecl(::google::protobuf::Arena* arena);
  DoctypeDecl(::google::protobuf::Arena* arena, const DoctypeDecl& from);
  DoctypeDecl(::google::protobuf::Arena* arena, DoctypeDecl&& from) noexcept
      : DoctypeDecl(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;
  static void* PlacementNew_(const void*, void* mem,
                             ::google::protobuf::Arena* arena);
  static constexpr auto InternalNewImpl_();
  static const ::google::protobuf::internal::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kMiskFieldNumber = 4,
    kNameFieldNumber = 1,
    kExternalIdFieldNumber = 2,
    kIntSubsetFieldNumber = 3,
  };
  // repeated .protobuf_mutator.xml.Misk misk = 4;
  int misk_size() const;
  private:
  int _internal_misk_size() const;

  public:
  void clear_misk() ;
  ::protobuf_mutator::xml::Misk* mutable_misk(int index);
  ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>* mutable_misk();

  private:
  const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>& _internal_misk() const;
  ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>* _internal_mutable_misk();
  public:
  const ::protobuf_mutator::xml::Misk& misk(int index) const;
  ::protobuf_mutator::xml::Misk* add_misk();
  const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>& misk() const;
  // optional string name = 1;
  bool has_name() const;
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  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:
  // optional string external_id = 2;
  bool has_external_id() const;
  void clear_external_id() ;
  const std::string& external_id() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_external_id(Arg_&& arg, Args_... args);
  std::string* mutable_external_id();
  PROTOBUF_NODISCARD std::string* release_external_id();
  void set_allocated_external_id(std::string* value);

  private:
  const std::string& _internal_external_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_external_id(
      const std::string& value);
  std::string* _internal_mutable_external_id();

  public:
  // optional string int_subset = 3;
  bool has_int_subset() const;
  void clear_int_subset() ;
  const std::string& int_subset() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_int_subset(Arg_&& arg, Args_... args);
  std::string* mutable_int_subset();
  PROTOBUF_NODISCARD std::string* release_int_subset();
  void set_allocated_int_subset(std::string* value);

  private:
  const std::string& _internal_int_subset() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_int_subset(
      const std::string& value);
  std::string* _internal_mutable_int_subset();

  public:
  // @@protoc_insertion_point(class_scope:protobuf_mutator.xml.DoctypeDecl)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 1,
      66, 2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const DoctypeDecl& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::protobuf_mutator::xml::Misk > misk_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr external_id_;
    ::google::protobuf::internal::ArenaStringPtr int_subset_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xml_2eproto;
};
// -------------------------------------------------------------------

class Content final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:protobuf_mutator.xml.Content) */ {
 public:
  inline Content() : Content(nullptr) {}
  ~Content() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Content* msg, std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Content));
  }
#endif

  template <typename = void>
  explicit PROTOBUF_CONSTEXPR Content(
      ::google::protobuf::internal::ConstantInitialized);

  inline Content(const Content& from) : Content(nullptr, from) {}
  inline Content(Content&& from) noexcept
      : Content(nullptr, std::move(from)) {}
  inline Content& operator=(const Content& from) {
    CopyFrom(from);
    return *this;
  }
  inline Content& operator=(Content&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Content& default_instance() {
    return *internal_default_instance();
  }
  enum Case {
    kCharData = 1,
    kElement = 2,
    kReference = 3,
    kCdsect = 4,
    kMisk = 5,
    __NOT_SET = 0,
  };
  static inline const Content* internal_default_instance() {
    return reinterpret_cast<const Content*>(
        &_Content_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(Content& a, Content& b) { a.Swap(&b); }
  inline void Swap(Content* other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Content* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Content* New(::google::protobuf::Arena* arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Content>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Content& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Content& from) { Content::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Content* other);
 private:
  template <typename T>
  friend ::absl::string_view(
      ::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "protobuf_mutator.xml.Content"; }

 protected:
  explicit Content(::google::protobuf::Arena* arena);
  Content(::google::protobuf::Arena* arena, const Content& from);
  Content(::google::protobuf::Arena* arena, Content&& from) noexcept
      : Content(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;
  static void* PlacementNew_(const void*, void* mem,
                             ::google::protobuf::Arena* arena);
  static constexpr auto InternalNewImpl_();
  static const ::google::protobuf::internal::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kCharDataFieldNumber = 1,
    kElementFieldNumber = 2,
    kReferenceFieldNumber = 3,
    kCdsectFieldNumber = 4,
    kMiskFieldNumber = 5,
  };
  // string char_data = 1;
  bool has_char_data() const;
  void clear_char_data() ;
  const std::string& char_data() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_char_data(Arg_&& arg, Args_... args);
  std::string* mutable_char_data();
  PROTOBUF_NODISCARD std::string* release_char_data();
  void set_allocated_char_data(std::string* value);

  private:
  const std::string& _internal_char_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_char_data(
      const std::string& value);
  std::string* _internal_mutable_char_data();

  public:
  // .protobuf_mutator.xml.Element element = 2;
  bool has_element() const;
  private:
  bool _internal_has_element() const;

  public:
  void clear_element() ;
  const ::protobuf_mutator::xml::Element& element() const;
  PROTOBUF_NODISCARD ::protobuf_mutator::xml::Element* release_element();
  ::protobuf_mutator::xml::Element* mutable_element();
  void set_allocated_element(::protobuf_mutator::xml::Element* value);
  void unsafe_arena_set_allocated_element(::protobuf_mutator::xml::Element* value);
  ::protobuf_mutator::xml::Element* unsafe_arena_release_element();

  private:
  const ::protobuf_mutator::xml::Element& _internal_element() const;
  ::protobuf_mutator::xml::Element* _internal_mutable_element();

  public:
  // .protobuf_mutator.xml.Reference reference = 3;
  bool has_reference() const;
  private:
  bool _internal_has_reference() const;

  public:
  void clear_reference() ;
  const ::protobuf_mutator::xml::Reference& reference() const;
  PROTOBUF_NODISCARD ::protobuf_mutator::xml::Reference* release_reference();
  ::protobuf_mutator::xml::Reference* mutable_reference();
  void set_allocated_reference(::protobuf_mutator::xml::Reference* value);
  void unsafe_arena_set_allocated_reference(::protobuf_mutator::xml::Reference* value);
  ::protobuf_mutator::xml::Reference* unsafe_arena_release_reference();

  private:
  const ::protobuf_mutator::xml::Reference& _internal_reference() const;
  ::protobuf_mutator::xml::Reference* _internal_mutable_reference();

  public:
  // string cdsect = 4;
  bool has_cdsect() const;
  void clear_cdsect() ;
  const std::string& cdsect() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_cdsect(Arg_&& arg, Args_... args);
  std::string* mutable_cdsect();
  PROTOBUF_NODISCARD std::string* release_cdsect();
  void set_allocated_cdsect(std::string* value);

  private:
  const std::string& _internal_cdsect() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cdsect(
      const std::string& value);
  std::string* _internal_mutable_cdsect();

  public:
  // .protobuf_mutator.xml.Misk misk = 5;
  bool has_misk() const;
  private:
  bool _internal_has_misk() const;

  public:
  void clear_misk() ;
  const ::protobuf_mutator::xml::Misk& misk() const;
  PROTOBUF_NODISCARD ::protobuf_mutator::xml::Misk* release_misk();
  ::protobuf_mutator::xml::Misk* mutable_misk();
  void set_allocated_misk(::protobuf_mutator::xml::Misk* value);
  void unsafe_arena_set_allocated_misk(::protobuf_mutator::xml::Misk* value);
  ::protobuf_mutator::xml::Misk* unsafe_arena_release_misk();

  private:
  const ::protobuf_mutator::xml::Misk& _internal_misk() const;
  ::protobuf_mutator::xml::Misk* _internal_mutable_misk();

  public:
  void clear__();
  Case __case() const;
  // @@protoc_insertion_point(class_scope:protobuf_mutator.xml.Content)
 private:
  class _Internal;
  void set_has_char_data();
  void set_has_element();
  void set_has_reference();
  void set_has_cdsect();
  void set_has_misk();
  inline bool has__() const;
  inline void clear_has__();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 5, 3,
      52, 2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const Content& from_msg);
    union Union {
      constexpr Union() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::internal::ArenaStringPtr char_data_;
      ::protobuf_mutator::xml::Element* element_;
      ::protobuf_mutator::xml::Reference* reference_;
      ::google::protobuf::internal::ArenaStringPtr cdsect_;
      ::protobuf_mutator::xml::Misk* misk_;
    } __;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xml_2eproto;
};
// -------------------------------------------------------------------

class Element final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:protobuf_mutator.xml.Element) */ {
 public:
  inline Element() : Element(nullptr) {}
  ~Element() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Element* msg, std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Element));
  }
#endif

  template <typename = void>
  explicit PROTOBUF_CONSTEXPR Element(
      ::google::protobuf::internal::ConstantInitialized);

  inline Element(const Element& from) : Element(nullptr, from) {}
  inline Element(Element&& from) noexcept
      : Element(nullptr, std::move(from)) {}
  inline Element& operator=(const Element& from) {
    CopyFrom(from);
    return *this;
  }
  inline Element& operator=(Element&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Element& default_instance() {
    return *internal_default_instance();
  }
  static inline const Element* internal_default_instance() {
    return reinterpret_cast<const Element*>(
        &_Element_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(Element& a, Element& b) { a.Swap(&b); }
  inline void Swap(Element* other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Element* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Element* New(::google::protobuf::Arena* arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Element>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Element& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Element& from) { Element::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Element* other);
 private:
  template <typename T>
  friend ::absl::string_view(
      ::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "protobuf_mutator.xml.Element"; }

 protected:
  explicit Element(::google::protobuf::Arena* arena);
  Element(::google::protobuf::Arena* arena, const Element& from);
  Element(::google::protobuf::Arena* arena, Element&& from) noexcept
      : Element(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;
  static void* PlacementNew_(const void*, void* mem,
                             ::google::protobuf::Arena* arena);
  static constexpr auto InternalNewImpl_();
  static const ::google::protobuf::internal::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kContentFieldNumber = 2,
    kTagFieldNumber = 1,
  };
  // repeated .protobuf_mutator.xml.Content content = 2;
  int content_size() const;
  private:
  int _internal_content_size() const;

  public:
  void clear_content() ;
  ::protobuf_mutator::xml::Content* mutable_content(int index);
  ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Content>* mutable_content();

  private:
  const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Content>& _internal_content() const;
  ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Content>* _internal_mutable_content();
  public:
  const ::protobuf_mutator::xml::Content& content(int index) const;
  ::protobuf_mutator::xml::Content* add_content();
  const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Content>& content() const;
  // optional .protobuf_mutator.xml.Tag tag = 1;
  bool has_tag() const;
  void clear_tag() ;
  const ::protobuf_mutator::xml::Tag& tag() const;
  PROTOBUF_NODISCARD ::protobuf_mutator::xml::Tag* release_tag();
  ::protobuf_mutator::xml::Tag* mutable_tag();
  void set_allocated_tag(::protobuf_mutator::xml::Tag* value);
  void unsafe_arena_set_allocated_tag(::protobuf_mutator::xml::Tag* value);
  ::protobuf_mutator::xml::Tag* unsafe_arena_release_tag();

  private:
  const ::protobuf_mutator::xml::Tag& _internal_tag() const;
  ::protobuf_mutator::xml::Tag* _internal_mutable_tag();

  public:
  // @@protoc_insertion_point(class_scope:protobuf_mutator.xml.Element)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const Element& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::protobuf_mutator::xml::Content > content_;
    ::protobuf_mutator::xml::Tag* tag_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xml_2eproto;
};
// -------------------------------------------------------------------

class Document final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:protobuf_mutator.xml.Document) */ {
 public:
  inline Document() : Document(nullptr) {}
  ~Document() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Document* msg, std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Document));
  }
#endif

  template <typename = void>
  explicit PROTOBUF_CONSTEXPR Document(
      ::google::protobuf::internal::ConstantInitialized);

  inline Document(const Document& from) : Document(nullptr, from) {}
  inline Document(Document&& from) noexcept
      : Document(nullptr, std::move(from)) {}
  inline Document& operator=(const Document& from) {
    CopyFrom(from);
    return *this;
  }
  inline Document& operator=(Document&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Document& default_instance() {
    return *internal_default_instance();
  }
  static inline const Document* internal_default_instance() {
    return reinterpret_cast<const Document*>(
        &_Document_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(Document& a, Document& b) { a.Swap(&b); }
  inline void Swap(Document* other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Document* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Document* New(::google::protobuf::Arena* arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Document>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Document& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Document& from) { Document::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Document* other);
 private:
  template <typename T>
  friend ::absl::string_view(
      ::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "protobuf_mutator.xml.Document"; }

 protected:
  explicit Document(::google::protobuf::Arena* arena);
  Document(::google::protobuf::Arena* arena, const Document& from);
  Document(::google::protobuf::Arena* arena, Document&& from) noexcept
      : Document(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;
  static void* PlacementNew_(const void*, void* mem,
                             ::google::protobuf::Arena* arena);
  static constexpr auto InternalNewImpl_();
  static const ::google::protobuf::internal::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kMisk1FieldNumber = 4,
    kMisk2FieldNumber = 7,
    kVersionFieldNumber = 1,
    kEncodingFieldNumber = 2,
    kDoctypeFieldNumber = 5,
    kElementFieldNumber = 6,
    kStandaloneFieldNumber = 3,
  };
  // repeated .protobuf_mutator.xml.Misk misk1 = 4;
  int misk1_size() const;
  private:
  int _internal_misk1_size() const;

  public:
  void clear_misk1() ;
  ::protobuf_mutator::xml::Misk* mutable_misk1(int index);
  ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>* mutable_misk1();

  private:
  const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>& _internal_misk1() const;
  ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>* _internal_mutable_misk1();
  public:
  const ::protobuf_mutator::xml::Misk& misk1(int index) const;
  ::protobuf_mutator::xml::Misk* add_misk1();
  const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>& misk1() const;
  // repeated .protobuf_mutator.xml.Misk misk2 = 7;
  int misk2_size() const;
  private:
  int _internal_misk2_size() const;

  public:
  void clear_misk2() ;
  ::protobuf_mutator::xml::Misk* mutable_misk2(int index);
  ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>* mutable_misk2();

  private:
  const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>& _internal_misk2() const;
  ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>* _internal_mutable_misk2();
  public:
  const ::protobuf_mutator::xml::Misk& misk2(int index) const;
  ::protobuf_mutator::xml::Misk* add_misk2();
  const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>& misk2() const;
  // optional string version = 1;
  bool has_version() const;
  void clear_version() ;
  const std::string& version() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_version(Arg_&& arg, Args_... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* value);

  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(
      const std::string& value);
  std::string* _internal_mutable_version();

  public:
  // optional string encoding = 2;
  bool has_encoding() const;
  void clear_encoding() ;
  const std::string& encoding() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_encoding(Arg_&& arg, Args_... args);
  std::string* mutable_encoding();
  PROTOBUF_NODISCARD std::string* release_encoding();
  void set_allocated_encoding(std::string* value);

  private:
  const std::string& _internal_encoding() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoding(
      const std::string& value);
  std::string* _internal_mutable_encoding();

  public:
  // optional .protobuf_mutator.xml.DoctypeDecl doctype = 5;
  bool has_doctype() const;
  void clear_doctype() ;
  const ::protobuf_mutator::xml::DoctypeDecl& doctype() const;
  PROTOBUF_NODISCARD ::protobuf_mutator::xml::DoctypeDecl* release_doctype();
  ::protobuf_mutator::xml::DoctypeDecl* mutable_doctype();
  void set_allocated_doctype(::protobuf_mutator::xml::DoctypeDecl* value);
  void unsafe_arena_set_allocated_doctype(::protobuf_mutator::xml::DoctypeDecl* value);
  ::protobuf_mutator::xml::DoctypeDecl* unsafe_arena_release_doctype();

  private:
  const ::protobuf_mutator::xml::DoctypeDecl& _internal_doctype() const;
  ::protobuf_mutator::xml::DoctypeDecl* _internal_mutable_doctype();

  public:
  // optional .protobuf_mutator.xml.Element element = 6;
  bool has_element() const;
  void clear_element() ;
  const ::protobuf_mutator::xml::Element& element() const;
  PROTOBUF_NODISCARD ::protobuf_mutator::xml::Element* release_element();
  ::protobuf_mutator::xml::Element* mutable_element();
  void set_allocated_element(::protobuf_mutator::xml::Element* value);
  void unsafe_arena_set_allocated_element(::protobuf_mutator::xml::Element* value);
  ::protobuf_mutator::xml::Element* unsafe_arena_release_element();

  private:
  const ::protobuf_mutator::xml::Element& _internal_element() const;
  ::protobuf_mutator::xml::Element* _internal_mutable_element();

  public:
  // optional bool standalone = 3;
  bool has_standalone() const;
  void clear_standalone() ;
  bool standalone() const;
  void set_standalone(bool value);

  private:
  bool _internal_standalone() const;
  void _internal_set_standalone(bool value);

  public:
  // @@protoc_insertion_point(class_scope:protobuf_mutator.xml.Document)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 4,
      53, 2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const Document& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::protobuf_mutator::xml::Misk > misk1_;
    ::google::protobuf::RepeatedPtrField< ::protobuf_mutator::xml::Misk > misk2_;
    ::google::protobuf::internal::ArenaStringPtr version_;
    ::google::protobuf::internal::ArenaStringPtr encoding_;
    ::protobuf_mutator::xml::DoctypeDecl* doctype_;
    ::protobuf_mutator::xml::Element* element_;
    bool standalone_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xml_2eproto;
};
// -------------------------------------------------------------------

class Input final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:protobuf_mutator.xml.Input) */ {
 public:
  inline Input() : Input(nullptr) {}
  ~Input() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Input* msg, std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Input));
  }
#endif

  template <typename = void>
  explicit PROTOBUF_CONSTEXPR Input(
      ::google::protobuf::internal::ConstantInitialized);

  inline Input(const Input& from) : Input(nullptr, from) {}
  inline Input(Input&& from) noexcept
      : Input(nullptr, std::move(from)) {}
  inline Input& operator=(const Input& from) {
    CopyFrom(from);
    return *this;
  }
  inline Input& operator=(Input&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Input& default_instance() {
    return *internal_default_instance();
  }
  static inline const Input* internal_default_instance() {
    return reinterpret_cast<const Input*>(
        &_Input_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 9;
  friend void swap(Input& a, Input& b) { a.Swap(&b); }
  inline void Swap(Input* other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Input* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Input* New(::google::protobuf::Arena* arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<Input>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const Input& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const Input& from) { Input::MergeImpl(*this, from); }

  private:
  static void MergeImpl(
      ::google::protobuf::MessageLite& to_msg,
      const ::google::protobuf::MessageLite& from_msg);

  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* _InternalSerialize(
      const MessageLite& msg, ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream);

  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Input* other);
 private:
  template <typename T>
  friend ::absl::string_view(
      ::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "protobuf_mutator.xml.Input"; }

 protected:
  explicit Input(::google::protobuf::Arena* arena);
  Input(::google::protobuf::Arena* arena, const Input& from);
  Input(::google::protobuf::Arena* arena, Input&& from) noexcept
      : Input(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL;
  static void* PlacementNew_(const void*, void* mem,
                             ::google::protobuf::Arena* arena);
  static constexpr auto InternalNewImpl_();
  static const ::google::protobuf::internal::ClassDataFull _class_data_;

 public:
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDocumentFieldNumber = 1,
    kOptionsFieldNumber = 2,
  };
  // optional .protobuf_mutator.xml.Document document = 1;
  bool has_document() const;
  void clear_document() ;
  const ::protobuf_mutator::xml::Document& document() const;
  PROTOBUF_NODISCARD ::protobuf_mutator::xml::Document* release_document();
  ::protobuf_mutator::xml::Document* mutable_document();
  void set_allocated_document(::protobuf_mutator::xml::Document* value);
  void unsafe_arena_set_allocated_document(::protobuf_mutator::xml::Document* value);
  ::protobuf_mutator::xml::Document* unsafe_arena_release_document();

  private:
  const ::protobuf_mutator::xml::Document& _internal_document() const;
  ::protobuf_mutator::xml::Document* _internal_mutable_document();

  public:
  // optional uint32 options = 2;
  bool has_options() const;
  void clear_options() ;
  ::uint32_t options() const;
  void set_options(::uint32_t value);

  private:
  ::uint32_t _internal_options() const;
  void _internal_set_options(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:protobuf_mutator.xml.Input)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      0, 2>
      _table_;

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from,
                          const Input& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::protobuf_mutator::xml::Document* document_;
    ::uint32_t options_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_xml_2eproto;
};

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




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


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// Document

// optional string version = 1;
inline bool Document::has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void Document::clear_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Document::version() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.version)
  return _internal_version();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Document::set_version(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.version_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Document.version)
}
inline std::string* Document::mutable_version() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Document.version)
  return _s;
}
inline const std::string& Document::_internal_version() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.version_.Get();
}
inline void Document::_internal_set_version(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.version_.Set(value, GetArena());
}
inline std::string* Document::_internal_mutable_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.version_.Mutable( GetArena());
}
inline std::string* Document::release_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Document.version)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* released = _impl_.version_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.version_.Set("", GetArena());
  }
  return released;
}
inline void Document::set_allocated_version(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.version_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Document.version)
}

// optional string encoding = 2;
inline bool Document::has_encoding() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void Document::clear_encoding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.encoding_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Document::encoding() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.encoding)
  return _internal_encoding();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Document::set_encoding(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.encoding_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Document.encoding)
}
inline std::string* Document::mutable_encoding() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_encoding();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Document.encoding)
  return _s;
}
inline const std::string& Document::_internal_encoding() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.encoding_.Get();
}
inline void Document::_internal_set_encoding(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.encoding_.Set(value, GetArena());
}
inline std::string* Document::_internal_mutable_encoding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.encoding_.Mutable( GetArena());
}
inline std::string* Document::release_encoding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Document.encoding)
  if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* released = _impl_.encoding_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.encoding_.Set("", GetArena());
  }
  return released;
}
inline void Document::set_allocated_encoding(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.encoding_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.encoding_.IsDefault()) {
    _impl_.encoding_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Document.encoding)
}

// optional bool standalone = 3;
inline bool Document::has_standalone() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline void Document::clear_standalone() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.standalone_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool Document::standalone() const {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.standalone)
  return _internal_standalone();
}
inline void Document::set_standalone(bool value) {
  _internal_set_standalone(value);
  _impl_._has_bits_[0] |= 0x00000010u;
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Document.standalone)
}
inline bool Document::_internal_standalone() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.standalone_;
}
inline void Document::_internal_set_standalone(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.standalone_ = value;
}

// repeated .protobuf_mutator.xml.Misk misk1 = 4;
inline int Document::_internal_misk1_size() const {
  return _internal_misk1().size();
}
inline int Document::misk1_size() const {
  return _internal_misk1_size();
}
inline void Document::clear_misk1() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.misk1_.Clear();
}
inline ::protobuf_mutator::xml::Misk* Document::mutable_misk1(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Document.misk1)
  return _internal_mutable_misk1()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>* Document::mutable_misk1()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:protobuf_mutator.xml.Document.misk1)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_misk1();
}
inline const ::protobuf_mutator::xml::Misk& Document::misk1(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.misk1)
  return _internal_misk1().Get(index);
}
inline ::protobuf_mutator::xml::Misk* Document::add_misk1() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::protobuf_mutator::xml::Misk* _add = _internal_mutable_misk1()->Add();
  // @@protoc_insertion_point(field_add:protobuf_mutator.xml.Document.misk1)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>& Document::misk1() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:protobuf_mutator.xml.Document.misk1)
  return _internal_misk1();
}
inline const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>&
Document::_internal_misk1() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.misk1_;
}
inline ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>*
Document::_internal_mutable_misk1() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.misk1_;
}

// optional .protobuf_mutator.xml.DoctypeDecl doctype = 5;
inline bool Document::has_doctype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.doctype_ != nullptr);
  return value;
}
inline void Document::clear_doctype() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.doctype_ != nullptr) _impl_.doctype_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::protobuf_mutator::xml::DoctypeDecl& Document::_internal_doctype() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::protobuf_mutator::xml::DoctypeDecl* p = _impl_.doctype_;
  return p != nullptr ? *p : reinterpret_cast<const ::protobuf_mutator::xml::DoctypeDecl&>(::protobuf_mutator::xml::_DoctypeDecl_default_instance_);
}
inline const ::protobuf_mutator::xml::DoctypeDecl& Document::doctype() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.doctype)
  return _internal_doctype();
}
inline void Document::unsafe_arena_set_allocated_doctype(::protobuf_mutator::xml::DoctypeDecl* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.doctype_);
  }
  _impl_.doctype_ = reinterpret_cast<::protobuf_mutator::xml::DoctypeDecl*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_mutator.xml.Document.doctype)
}
inline ::protobuf_mutator::xml::DoctypeDecl* Document::release_doctype() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::protobuf_mutator::xml::DoctypeDecl* released = _impl_.doctype_;
  _impl_.doctype_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::protobuf_mutator::xml::DoctypeDecl* Document::unsafe_arena_release_doctype() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Document.doctype)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::protobuf_mutator::xml::DoctypeDecl* temp = _impl_.doctype_;
  _impl_.doctype_ = nullptr;
  return temp;
}
inline ::protobuf_mutator::xml::DoctypeDecl* Document::_internal_mutable_doctype() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.doctype_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::protobuf_mutator::xml::DoctypeDecl>(GetArena());
    _impl_.doctype_ = reinterpret_cast<::protobuf_mutator::xml::DoctypeDecl*>(p);
  }
  return _impl_.doctype_;
}
inline ::protobuf_mutator::xml::DoctypeDecl* Document::mutable_doctype() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000004u;
  ::protobuf_mutator::xml::DoctypeDecl* _msg = _internal_mutable_doctype();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Document.doctype)
  return _msg;
}
inline void Document::set_allocated_doctype(::protobuf_mutator::xml::DoctypeDecl* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.doctype_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.doctype_ = reinterpret_cast<::protobuf_mutator::xml::DoctypeDecl*>(value);
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Document.doctype)
}

// optional .protobuf_mutator.xml.Element element = 6;
inline bool Document::has_element() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.element_ != nullptr);
  return value;
}
inline void Document::clear_element() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.element_ != nullptr) _impl_.element_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::protobuf_mutator::xml::Element& Document::_internal_element() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::protobuf_mutator::xml::Element* p = _impl_.element_;
  return p != nullptr ? *p : reinterpret_cast<const ::protobuf_mutator::xml::Element&>(::protobuf_mutator::xml::_Element_default_instance_);
}
inline const ::protobuf_mutator::xml::Element& Document::element() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.element)
  return _internal_element();
}
inline void Document::unsafe_arena_set_allocated_element(::protobuf_mutator::xml::Element* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.element_);
  }
  _impl_.element_ = reinterpret_cast<::protobuf_mutator::xml::Element*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_mutator.xml.Document.element)
}
inline ::protobuf_mutator::xml::Element* Document::release_element() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::protobuf_mutator::xml::Element* released = _impl_.element_;
  _impl_.element_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::protobuf_mutator::xml::Element* Document::unsafe_arena_release_element() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Document.element)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::protobuf_mutator::xml::Element* temp = _impl_.element_;
  _impl_.element_ = nullptr;
  return temp;
}
inline ::protobuf_mutator::xml::Element* Document::_internal_mutable_element() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.element_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::protobuf_mutator::xml::Element>(GetArena());
    _impl_.element_ = reinterpret_cast<::protobuf_mutator::xml::Element*>(p);
  }
  return _impl_.element_;
}
inline ::protobuf_mutator::xml::Element* Document::mutable_element() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000008u;
  ::protobuf_mutator::xml::Element* _msg = _internal_mutable_element();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Document.element)
  return _msg;
}
inline void Document::set_allocated_element(::protobuf_mutator::xml::Element* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.element_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.element_ = reinterpret_cast<::protobuf_mutator::xml::Element*>(value);
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Document.element)
}

// repeated .protobuf_mutator.xml.Misk misk2 = 7;
inline int Document::_internal_misk2_size() const {
  return _internal_misk2().size();
}
inline int Document::misk2_size() const {
  return _internal_misk2_size();
}
inline void Document::clear_misk2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.misk2_.Clear();
}
inline ::protobuf_mutator::xml::Misk* Document::mutable_misk2(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Document.misk2)
  return _internal_mutable_misk2()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>* Document::mutable_misk2()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:protobuf_mutator.xml.Document.misk2)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_misk2();
}
inline const ::protobuf_mutator::xml::Misk& Document::misk2(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Document.misk2)
  return _internal_misk2().Get(index);
}
inline ::protobuf_mutator::xml::Misk* Document::add_misk2() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::protobuf_mutator::xml::Misk* _add = _internal_mutable_misk2()->Add();
  // @@protoc_insertion_point(field_add:protobuf_mutator.xml.Document.misk2)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>& Document::misk2() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:protobuf_mutator.xml.Document.misk2)
  return _internal_misk2();
}
inline const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>&
Document::_internal_misk2() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.misk2_;
}
inline ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>*
Document::_internal_mutable_misk2() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.misk2_;
}

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

// DoctypeDecl

// optional string name = 1;
inline bool DoctypeDecl::has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void DoctypeDecl::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DoctypeDecl::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.DoctypeDecl.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DoctypeDecl::set_name(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.DoctypeDecl.name)
}
inline std::string* DoctypeDecl::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.DoctypeDecl.name)
  return _s;
}
inline const std::string& DoctypeDecl::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void DoctypeDecl::_internal_set_name(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* DoctypeDecl::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* DoctypeDecl::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.DoctypeDecl.name)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void DoctypeDecl::set_allocated_name(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.DoctypeDecl.name)
}

// optional string external_id = 2;
inline bool DoctypeDecl::has_external_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void DoctypeDecl::clear_external_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.external_id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DoctypeDecl::external_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.DoctypeDecl.external_id)
  return _internal_external_id();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DoctypeDecl::set_external_id(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.external_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.DoctypeDecl.external_id)
}
inline std::string* DoctypeDecl::mutable_external_id() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_external_id();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.DoctypeDecl.external_id)
  return _s;
}
inline const std::string& DoctypeDecl::_internal_external_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.external_id_.Get();
}
inline void DoctypeDecl::_internal_set_external_id(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.external_id_.Set(value, GetArena());
}
inline std::string* DoctypeDecl::_internal_mutable_external_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.external_id_.Mutable( GetArena());
}
inline std::string* DoctypeDecl::release_external_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.DoctypeDecl.external_id)
  if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* released = _impl_.external_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.external_id_.Set("", GetArena());
  }
  return released;
}
inline void DoctypeDecl::set_allocated_external_id(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.external_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.external_id_.IsDefault()) {
    _impl_.external_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.DoctypeDecl.external_id)
}

// optional string int_subset = 3;
inline bool DoctypeDecl::has_int_subset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void DoctypeDecl::clear_int_subset() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.int_subset_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& DoctypeDecl::int_subset() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.DoctypeDecl.int_subset)
  return _internal_int_subset();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DoctypeDecl::set_int_subset(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.int_subset_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.DoctypeDecl.int_subset)
}
inline std::string* DoctypeDecl::mutable_int_subset() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_int_subset();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.DoctypeDecl.int_subset)
  return _s;
}
inline const std::string& DoctypeDecl::_internal_int_subset() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.int_subset_.Get();
}
inline void DoctypeDecl::_internal_set_int_subset(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.int_subset_.Set(value, GetArena());
}
inline std::string* DoctypeDecl::_internal_mutable_int_subset() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.int_subset_.Mutable( GetArena());
}
inline std::string* DoctypeDecl::release_int_subset() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.DoctypeDecl.int_subset)
  if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* released = _impl_.int_subset_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.int_subset_.Set("", GetArena());
  }
  return released;
}
inline void DoctypeDecl::set_allocated_int_subset(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.int_subset_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.int_subset_.IsDefault()) {
    _impl_.int_subset_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.DoctypeDecl.int_subset)
}

// repeated .protobuf_mutator.xml.Misk misk = 4;
inline int DoctypeDecl::_internal_misk_size() const {
  return _internal_misk().size();
}
inline int DoctypeDecl::misk_size() const {
  return _internal_misk_size();
}
inline void DoctypeDecl::clear_misk() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.misk_.Clear();
}
inline ::protobuf_mutator::xml::Misk* DoctypeDecl::mutable_misk(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.DoctypeDecl.misk)
  return _internal_mutable_misk()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>* DoctypeDecl::mutable_misk()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:protobuf_mutator.xml.DoctypeDecl.misk)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_misk();
}
inline const ::protobuf_mutator::xml::Misk& DoctypeDecl::misk(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.DoctypeDecl.misk)
  return _internal_misk().Get(index);
}
inline ::protobuf_mutator::xml::Misk* DoctypeDecl::add_misk() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::protobuf_mutator::xml::Misk* _add = _internal_mutable_misk()->Add();
  // @@protoc_insertion_point(field_add:protobuf_mutator.xml.DoctypeDecl.misk)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>& DoctypeDecl::misk() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:protobuf_mutator.xml.DoctypeDecl.misk)
  return _internal_misk();
}
inline const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>&
DoctypeDecl::_internal_misk() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.misk_;
}
inline ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Misk>*
DoctypeDecl::_internal_mutable_misk() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.misk_;
}

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

// Misk

// .protobuf_mutator.xml.Pi pi = 1;
inline bool Misk::has_pi() const {
  return __case() == kPi;
}
inline bool Misk::_internal_has_pi() const {
  return __case() == kPi;
}
inline void Misk::set_has_pi() {
  _impl_._oneof_case_[0] = kPi;
}
inline void Misk::clear_pi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() == kPi) {
    if (GetArena() == nullptr) {
      delete _impl_.__.pi_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.__.pi_);
    }
    clear_has__();
  }
}
inline ::protobuf_mutator::xml::Pi* Misk::release_pi() {
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Misk.pi)
  if (__case() == kPi) {
    clear_has__();
    auto* temp = _impl_.__.pi_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.__.pi_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::protobuf_mutator::xml::Pi& Misk::_internal_pi() const {
  return __case() == kPi ? *_impl_.__.pi_ : reinterpret_cast<::protobuf_mutator::xml::Pi&>(::protobuf_mutator::xml::_Pi_default_instance_);
}
inline const ::protobuf_mutator::xml::Pi& Misk::pi() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Misk.pi)
  return _internal_pi();
}
inline ::protobuf_mutator::xml::Pi* Misk::unsafe_arena_release_pi() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_mutator.xml.Misk.pi)
  if (__case() == kPi) {
    clear_has__();
    auto* temp = _impl_.__.pi_;
    _impl_.__.pi_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Misk::unsafe_arena_set_allocated_pi(::protobuf_mutator::xml::Pi* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear__();
  if (value) {
    set_has_pi();
    _impl_.__.pi_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_mutator.xml.Misk.pi)
}
inline ::protobuf_mutator::xml::Pi* Misk::_internal_mutable_pi() {
  if (__case() != kPi) {
    clear__();
    set_has_pi();
    _impl_.__.pi_ =
        ::google::protobuf::Message::DefaultConstruct<::protobuf_mutator::xml::Pi>(GetArena());
  }
  return _impl_.__.pi_;
}
inline ::protobuf_mutator::xml::Pi* Misk::mutable_pi() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::protobuf_mutator::xml::Pi* _msg = _internal_mutable_pi();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Misk.pi)
  return _msg;
}

// string comment = 2;
inline bool Misk::has_comment() const {
  return __case() == kComment;
}
inline void Misk::set_has_comment() {
  _impl_._oneof_case_[0] = kComment;
}
inline void Misk::clear_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() == kComment) {
    _impl_.__.comment_.Destroy();
    clear_has__();
  }
}
inline const std::string& Misk::comment() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Misk.comment)
  return _internal_comment();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Misk::set_comment(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() != kComment) {
    clear__();

    set_has_comment();
    _impl_.__.comment_.InitDefault();
  }
  _impl_.__.comment_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Misk.comment)
}
inline std::string* Misk::mutable_comment() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_comment();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Misk.comment)
  return _s;
}
inline const std::string& Misk::_internal_comment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (__case() != kComment) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.__.comment_.Get();
}
inline void Misk::_internal_set_comment(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() != kComment) {
    clear__();

    set_has_comment();
    _impl_.__.comment_.InitDefault();
  }
  _impl_.__.comment_.Set(value, GetArena());
}
inline std::string* Misk::_internal_mutable_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() != kComment) {
    clear__();

    set_has_comment();
    _impl_.__.comment_.InitDefault();
  }
  return _impl_.__.comment_.Mutable( GetArena());
}
inline std::string* Misk::release_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Misk.comment)
  if (__case() != kComment) {
    return nullptr;
  }
  clear_has__();
  return _impl_.__.comment_.Release();
}
inline void Misk::set_allocated_comment(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has__()) {
    clear__();
  }
  if (value != nullptr) {
    set_has_comment();
    _impl_.__.comment_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Misk.comment)
}

inline bool Misk::has__() const {
  return __case() != __NOT_SET;
}
inline void Misk::clear_has__() {
  _impl_._oneof_case_[0] = __NOT_SET;
}
inline Misk::Case Misk::__case() const {
  return Misk::Case(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Element

// optional .protobuf_mutator.xml.Tag tag = 1;
inline bool Element::has_tag() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.tag_ != nullptr);
  return value;
}
inline void Element::clear_tag() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.tag_ != nullptr) _impl_.tag_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::protobuf_mutator::xml::Tag& Element::_internal_tag() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::protobuf_mutator::xml::Tag* p = _impl_.tag_;
  return p != nullptr ? *p : reinterpret_cast<const ::protobuf_mutator::xml::Tag&>(::protobuf_mutator::xml::_Tag_default_instance_);
}
inline const ::protobuf_mutator::xml::Tag& Element::tag() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Element.tag)
  return _internal_tag();
}
inline void Element::unsafe_arena_set_allocated_tag(::protobuf_mutator::xml::Tag* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tag_);
  }
  _impl_.tag_ = reinterpret_cast<::protobuf_mutator::xml::Tag*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_mutator.xml.Element.tag)
}
inline ::protobuf_mutator::xml::Tag* Element::release_tag() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::protobuf_mutator::xml::Tag* released = _impl_.tag_;
  _impl_.tag_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::protobuf_mutator::xml::Tag* Element::unsafe_arena_release_tag() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Element.tag)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::protobuf_mutator::xml::Tag* temp = _impl_.tag_;
  _impl_.tag_ = nullptr;
  return temp;
}
inline ::protobuf_mutator::xml::Tag* Element::_internal_mutable_tag() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.tag_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::protobuf_mutator::xml::Tag>(GetArena());
    _impl_.tag_ = reinterpret_cast<::protobuf_mutator::xml::Tag*>(p);
  }
  return _impl_.tag_;
}
inline ::protobuf_mutator::xml::Tag* Element::mutable_tag() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::protobuf_mutator::xml::Tag* _msg = _internal_mutable_tag();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Element.tag)
  return _msg;
}
inline void Element::set_allocated_tag(::protobuf_mutator::xml::Tag* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.tag_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.tag_ = reinterpret_cast<::protobuf_mutator::xml::Tag*>(value);
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Element.tag)
}

// repeated .protobuf_mutator.xml.Content content = 2;
inline int Element::_internal_content_size() const {
  return _internal_content().size();
}
inline int Element::content_size() const {
  return _internal_content_size();
}
inline void Element::clear_content() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.content_.Clear();
}
inline ::protobuf_mutator::xml::Content* Element::mutable_content(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Element.content)
  return _internal_mutable_content()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Content>* Element::mutable_content()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:protobuf_mutator.xml.Element.content)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_content();
}
inline const ::protobuf_mutator::xml::Content& Element::content(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Element.content)
  return _internal_content().Get(index);
}
inline ::protobuf_mutator::xml::Content* Element::add_content() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::protobuf_mutator::xml::Content* _add = _internal_mutable_content()->Add();
  // @@protoc_insertion_point(field_add:protobuf_mutator.xml.Element.content)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Content>& Element::content() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:protobuf_mutator.xml.Element.content)
  return _internal_content();
}
inline const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Content>&
Element::_internal_content() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.content_;
}
inline ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Content>*
Element::_internal_mutable_content() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.content_;
}

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

// Tag

// optional string name = 1;
inline bool Tag::has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void Tag::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Tag::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Tag.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Tag::set_name(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Tag.name)
}
inline std::string* Tag::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Tag.name)
  return _s;
}
inline const std::string& Tag::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void Tag::_internal_set_name(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* Tag::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* Tag::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Tag.name)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void Tag::set_allocated_name(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Tag.name)
}

// repeated .protobuf_mutator.xml.Attribute attribute = 2;
inline int Tag::_internal_attribute_size() const {
  return _internal_attribute().size();
}
inline int Tag::attribute_size() const {
  return _internal_attribute_size();
}
inline void Tag::clear_attribute() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.attribute_.Clear();
}
inline ::protobuf_mutator::xml::Attribute* Tag::mutable_attribute(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Tag.attribute)
  return _internal_mutable_attribute()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Attribute>* Tag::mutable_attribute()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:protobuf_mutator.xml.Tag.attribute)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_attribute();
}
inline const ::protobuf_mutator::xml::Attribute& Tag::attribute(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Tag.attribute)
  return _internal_attribute().Get(index);
}
inline ::protobuf_mutator::xml::Attribute* Tag::add_attribute() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::protobuf_mutator::xml::Attribute* _add = _internal_mutable_attribute()->Add();
  // @@protoc_insertion_point(field_add:protobuf_mutator.xml.Tag.attribute)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Attribute>& Tag::attribute() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:protobuf_mutator.xml.Tag.attribute)
  return _internal_attribute();
}
inline const ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Attribute>&
Tag::_internal_attribute() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.attribute_;
}
inline ::google::protobuf::RepeatedPtrField<::protobuf_mutator::xml::Attribute>*
Tag::_internal_mutable_attribute() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.attribute_;
}

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

// Reference

// optional string name = 1;
inline bool Reference::has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void Reference::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Reference::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Reference.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Reference::set_name(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Reference.name)
}
inline std::string* Reference::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Reference.name)
  return _s;
}
inline const std::string& Reference::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void Reference::_internal_set_name(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* Reference::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* Reference::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Reference.name)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void Reference::set_allocated_name(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Reference.name)
}

// optional bool entry = 2;
inline bool Reference::has_entry() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void Reference::clear_entry() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.entry_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool Reference::entry() const {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Reference.entry)
  return _internal_entry();
}
inline void Reference::set_entry(bool value) {
  _internal_set_entry(value);
  _impl_._has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Reference.entry)
}
inline bool Reference::_internal_entry() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.entry_;
}
inline void Reference::_internal_set_entry(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.entry_ = value;
}

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

// Pi

// optional string target = 1;
inline bool Pi::has_target() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void Pi::clear_target() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Pi::target() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Pi.target)
  return _internal_target();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Pi::set_target(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.target_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Pi.target)
}
inline std::string* Pi::mutable_target() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_target();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Pi.target)
  return _s;
}
inline const std::string& Pi::_internal_target() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.target_.Get();
}
inline void Pi::_internal_set_target(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.target_.Set(value, GetArena());
}
inline std::string* Pi::_internal_mutable_target() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.target_.Mutable( GetArena());
}
inline std::string* Pi::release_target() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Pi.target)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* released = _impl_.target_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.target_.Set("", GetArena());
  }
  return released;
}
inline void Pi::set_allocated_target(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.target_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.target_.IsDefault()) {
    _impl_.target_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Pi.target)
}

// optional string data = 2;
inline bool Pi::has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void Pi::clear_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Pi::data() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Pi.data)
  return _internal_data();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Pi::set_data(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.data_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Pi.data)
}
inline std::string* Pi::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Pi.data)
  return _s;
}
inline const std::string& Pi::_internal_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.data_.Get();
}
inline void Pi::_internal_set_data(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.data_.Set(value, GetArena());
}
inline std::string* Pi::_internal_mutable_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.data_.Mutable( GetArena());
}
inline std::string* Pi::release_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Pi.data)
  if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* released = _impl_.data_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.data_.Set("", GetArena());
  }
  return released;
}
inline void Pi::set_allocated_data(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.data_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Pi.data)
}

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

// Content

// string char_data = 1;
inline bool Content::has_char_data() const {
  return __case() == kCharData;
}
inline void Content::set_has_char_data() {
  _impl_._oneof_case_[0] = kCharData;
}
inline void Content::clear_char_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() == kCharData) {
    _impl_.__.char_data_.Destroy();
    clear_has__();
  }
}
inline const std::string& Content::char_data() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Content.char_data)
  return _internal_char_data();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Content::set_char_data(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() != kCharData) {
    clear__();

    set_has_char_data();
    _impl_.__.char_data_.InitDefault();
  }
  _impl_.__.char_data_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Content.char_data)
}
inline std::string* Content::mutable_char_data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_char_data();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Content.char_data)
  return _s;
}
inline const std::string& Content::_internal_char_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (__case() != kCharData) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.__.char_data_.Get();
}
inline void Content::_internal_set_char_data(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() != kCharData) {
    clear__();

    set_has_char_data();
    _impl_.__.char_data_.InitDefault();
  }
  _impl_.__.char_data_.Set(value, GetArena());
}
inline std::string* Content::_internal_mutable_char_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() != kCharData) {
    clear__();

    set_has_char_data();
    _impl_.__.char_data_.InitDefault();
  }
  return _impl_.__.char_data_.Mutable( GetArena());
}
inline std::string* Content::release_char_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Content.char_data)
  if (__case() != kCharData) {
    return nullptr;
  }
  clear_has__();
  return _impl_.__.char_data_.Release();
}
inline void Content::set_allocated_char_data(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has__()) {
    clear__();
  }
  if (value != nullptr) {
    set_has_char_data();
    _impl_.__.char_data_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Content.char_data)
}

// .protobuf_mutator.xml.Element element = 2;
inline bool Content::has_element() const {
  return __case() == kElement;
}
inline bool Content::_internal_has_element() const {
  return __case() == kElement;
}
inline void Content::set_has_element() {
  _impl_._oneof_case_[0] = kElement;
}
inline void Content::clear_element() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() == kElement) {
    if (GetArena() == nullptr) {
      delete _impl_.__.element_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.__.element_);
    }
    clear_has__();
  }
}
inline ::protobuf_mutator::xml::Element* Content::release_element() {
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Content.element)
  if (__case() == kElement) {
    clear_has__();
    auto* temp = _impl_.__.element_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.__.element_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::protobuf_mutator::xml::Element& Content::_internal_element() const {
  return __case() == kElement ? *_impl_.__.element_ : reinterpret_cast<::protobuf_mutator::xml::Element&>(::protobuf_mutator::xml::_Element_default_instance_);
}
inline const ::protobuf_mutator::xml::Element& Content::element() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Content.element)
  return _internal_element();
}
inline ::protobuf_mutator::xml::Element* Content::unsafe_arena_release_element() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_mutator.xml.Content.element)
  if (__case() == kElement) {
    clear_has__();
    auto* temp = _impl_.__.element_;
    _impl_.__.element_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Content::unsafe_arena_set_allocated_element(::protobuf_mutator::xml::Element* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear__();
  if (value) {
    set_has_element();
    _impl_.__.element_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_mutator.xml.Content.element)
}
inline ::protobuf_mutator::xml::Element* Content::_internal_mutable_element() {
  if (__case() != kElement) {
    clear__();
    set_has_element();
    _impl_.__.element_ =
        ::google::protobuf::Message::DefaultConstruct<::protobuf_mutator::xml::Element>(GetArena());
  }
  return _impl_.__.element_;
}
inline ::protobuf_mutator::xml::Element* Content::mutable_element() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::protobuf_mutator::xml::Element* _msg = _internal_mutable_element();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Content.element)
  return _msg;
}

// .protobuf_mutator.xml.Reference reference = 3;
inline bool Content::has_reference() const {
  return __case() == kReference;
}
inline bool Content::_internal_has_reference() const {
  return __case() == kReference;
}
inline void Content::set_has_reference() {
  _impl_._oneof_case_[0] = kReference;
}
inline void Content::clear_reference() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() == kReference) {
    if (GetArena() == nullptr) {
      delete _impl_.__.reference_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.__.reference_);
    }
    clear_has__();
  }
}
inline ::protobuf_mutator::xml::Reference* Content::release_reference() {
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Content.reference)
  if (__case() == kReference) {
    clear_has__();
    auto* temp = _impl_.__.reference_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.__.reference_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::protobuf_mutator::xml::Reference& Content::_internal_reference() const {
  return __case() == kReference ? *_impl_.__.reference_ : reinterpret_cast<::protobuf_mutator::xml::Reference&>(::protobuf_mutator::xml::_Reference_default_instance_);
}
inline const ::protobuf_mutator::xml::Reference& Content::reference() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Content.reference)
  return _internal_reference();
}
inline ::protobuf_mutator::xml::Reference* Content::unsafe_arena_release_reference() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_mutator.xml.Content.reference)
  if (__case() == kReference) {
    clear_has__();
    auto* temp = _impl_.__.reference_;
    _impl_.__.reference_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Content::unsafe_arena_set_allocated_reference(::protobuf_mutator::xml::Reference* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear__();
  if (value) {
    set_has_reference();
    _impl_.__.reference_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_mutator.xml.Content.reference)
}
inline ::protobuf_mutator::xml::Reference* Content::_internal_mutable_reference() {
  if (__case() != kReference) {
    clear__();
    set_has_reference();
    _impl_.__.reference_ =
        ::google::protobuf::Message::DefaultConstruct<::protobuf_mutator::xml::Reference>(GetArena());
  }
  return _impl_.__.reference_;
}
inline ::protobuf_mutator::xml::Reference* Content::mutable_reference() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::protobuf_mutator::xml::Reference* _msg = _internal_mutable_reference();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Content.reference)
  return _msg;
}

// string cdsect = 4;
inline bool Content::has_cdsect() const {
  return __case() == kCdsect;
}
inline void Content::set_has_cdsect() {
  _impl_._oneof_case_[0] = kCdsect;
}
inline void Content::clear_cdsect() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() == kCdsect) {
    _impl_.__.cdsect_.Destroy();
    clear_has__();
  }
}
inline const std::string& Content::cdsect() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Content.cdsect)
  return _internal_cdsect();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Content::set_cdsect(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() != kCdsect) {
    clear__();

    set_has_cdsect();
    _impl_.__.cdsect_.InitDefault();
  }
  _impl_.__.cdsect_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Content.cdsect)
}
inline std::string* Content::mutable_cdsect() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_cdsect();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Content.cdsect)
  return _s;
}
inline const std::string& Content::_internal_cdsect() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  if (__case() != kCdsect) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.__.cdsect_.Get();
}
inline void Content::_internal_set_cdsect(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() != kCdsect) {
    clear__();

    set_has_cdsect();
    _impl_.__.cdsect_.InitDefault();
  }
  _impl_.__.cdsect_.Set(value, GetArena());
}
inline std::string* Content::_internal_mutable_cdsect() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() != kCdsect) {
    clear__();

    set_has_cdsect();
    _impl_.__.cdsect_.InitDefault();
  }
  return _impl_.__.cdsect_.Mutable( GetArena());
}
inline std::string* Content::release_cdsect() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Content.cdsect)
  if (__case() != kCdsect) {
    return nullptr;
  }
  clear_has__();
  return _impl_.__.cdsect_.Release();
}
inline void Content::set_allocated_cdsect(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (has__()) {
    clear__();
  }
  if (value != nullptr) {
    set_has_cdsect();
    _impl_.__.cdsect_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Content.cdsect)
}

// .protobuf_mutator.xml.Misk misk = 5;
inline bool Content::has_misk() const {
  return __case() == kMisk;
}
inline bool Content::_internal_has_misk() const {
  return __case() == kMisk;
}
inline void Content::set_has_misk() {
  _impl_._oneof_case_[0] = kMisk;
}
inline void Content::clear_misk() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (__case() == kMisk) {
    if (GetArena() == nullptr) {
      delete _impl_.__.misk_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.__.misk_);
    }
    clear_has__();
  }
}
inline ::protobuf_mutator::xml::Misk* Content::release_misk() {
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Content.misk)
  if (__case() == kMisk) {
    clear_has__();
    auto* temp = _impl_.__.misk_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.__.misk_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::protobuf_mutator::xml::Misk& Content::_internal_misk() const {
  return __case() == kMisk ? *_impl_.__.misk_ : reinterpret_cast<::protobuf_mutator::xml::Misk&>(::protobuf_mutator::xml::_Misk_default_instance_);
}
inline const ::protobuf_mutator::xml::Misk& Content::misk() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Content.misk)
  return _internal_misk();
}
inline ::protobuf_mutator::xml::Misk* Content::unsafe_arena_release_misk() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_mutator.xml.Content.misk)
  if (__case() == kMisk) {
    clear_has__();
    auto* temp = _impl_.__.misk_;
    _impl_.__.misk_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Content::unsafe_arena_set_allocated_misk(::protobuf_mutator::xml::Misk* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear__();
  if (value) {
    set_has_misk();
    _impl_.__.misk_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_mutator.xml.Content.misk)
}
inline ::protobuf_mutator::xml::Misk* Content::_internal_mutable_misk() {
  if (__case() != kMisk) {
    clear__();
    set_has_misk();
    _impl_.__.misk_ =
        ::google::protobuf::Message::DefaultConstruct<::protobuf_mutator::xml::Misk>(GetArena());
  }
  return _impl_.__.misk_;
}
inline ::protobuf_mutator::xml::Misk* Content::mutable_misk() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::protobuf_mutator::xml::Misk* _msg = _internal_mutable_misk();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Content.misk)
  return _msg;
}

inline bool Content::has__() const {
  return __case() != __NOT_SET;
}
inline void Content::clear_has__() {
  _impl_._oneof_case_[0] = __NOT_SET;
}
inline Content::Case Content::__case() const {
  return Content::Case(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Attribute

// optional string name = 1;
inline bool Attribute::has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void Attribute::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Attribute::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Attribute.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Attribute::set_name(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Attribute.name)
}
inline std::string* Attribute::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Attribute.name)
  return _s;
}
inline const std::string& Attribute::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void Attribute::_internal_set_name(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* Attribute::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* Attribute::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Attribute.name)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void Attribute::set_allocated_name(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Attribute.name)
}

// optional string value = 2;
inline bool Attribute::has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void Attribute::clear_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Attribute::value() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Attribute.value)
  return _internal_value();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Attribute::set_value(Arg_&& arg,
                                                     Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.value_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Attribute.value)
}
inline std::string* Attribute::mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Attribute.value)
  return _s;
}
inline const std::string& Attribute::_internal_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.value_.Get();
}
inline void Attribute::_internal_set_value(const std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.value_.Set(value, GetArena());
}
inline std::string* Attribute::_internal_mutable_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.value_.Mutable( GetArena());
}
inline std::string* Attribute::release_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Attribute.value)
  if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* released = _impl_.value_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.value_.Set("", GetArena());
  }
  return released;
}
inline void Attribute::set_allocated_value(std::string* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.value_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Attribute.value)
}

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

// Input

// optional .protobuf_mutator.xml.Document document = 1;
inline bool Input::has_document() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.document_ != nullptr);
  return value;
}
inline void Input::clear_document() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.document_ != nullptr) _impl_.document_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::protobuf_mutator::xml::Document& Input::_internal_document() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::protobuf_mutator::xml::Document* p = _impl_.document_;
  return p != nullptr ? *p : reinterpret_cast<const ::protobuf_mutator::xml::Document&>(::protobuf_mutator::xml::_Document_default_instance_);
}
inline const ::protobuf_mutator::xml::Document& Input::document() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Input.document)
  return _internal_document();
}
inline void Input::unsafe_arena_set_allocated_document(::protobuf_mutator::xml::Document* value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.document_);
  }
  _impl_.document_ = reinterpret_cast<::protobuf_mutator::xml::Document*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_mutator.xml.Input.document)
}
inline ::protobuf_mutator::xml::Document* Input::release_document() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::protobuf_mutator::xml::Document* released = _impl_.document_;
  _impl_.document_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::protobuf_mutator::xml::Document* Input::unsafe_arena_release_document() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:protobuf_mutator.xml.Input.document)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::protobuf_mutator::xml::Document* temp = _impl_.document_;
  _impl_.document_ = nullptr;
  return temp;
}
inline ::protobuf_mutator::xml::Document* Input::_internal_mutable_document() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.document_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::protobuf_mutator::xml::Document>(GetArena());
    _impl_.document_ = reinterpret_cast<::protobuf_mutator::xml::Document*>(p);
  }
  return _impl_.document_;
}
inline ::protobuf_mutator::xml::Document* Input::mutable_document() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::protobuf_mutator::xml::Document* _msg = _internal_mutable_document();
  // @@protoc_insertion_point(field_mutable:protobuf_mutator.xml.Input.document)
  return _msg;
}
inline void Input::set_allocated_document(::protobuf_mutator::xml::Document* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete (_impl_.document_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.document_ = reinterpret_cast<::protobuf_mutator::xml::Document*>(value);
  // @@protoc_insertion_point(field_set_allocated:protobuf_mutator.xml.Input.document)
}

// optional uint32 options = 2;
inline bool Input::has_options() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void Input::clear_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.options_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::uint32_t Input::options() const {
  // @@protoc_insertion_point(field_get:protobuf_mutator.xml.Input.options)
  return _internal_options();
}
inline void Input::set_options(::uint32_t value) {
  _internal_set_options(value);
  _impl_._has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_set:protobuf_mutator.xml.Input.options)
}
inline ::uint32_t Input::_internal_options() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.options_;
}
inline void Input::_internal_set_options(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.options_ = value;
}

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace xml
}  // namespace protobuf_mutator


// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // xml_2eproto_2epb_2eh

Coverage Report

Created: 2026-02-26 06:51