/src/genfiles/png_fuzz_proto.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_png_5ffuzz_5fproto_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_png_5ffuzz_5fproto_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021007 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_png_5ffuzz_5fproto_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_png_5ffuzz_5fproto_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_png_5ffuzz_5fproto_2eproto;
class IDAT;
struct IDATDefaultTypeInternal;
extern IDATDefaultTypeInternal _IDAT_default_instance_;
class IHDR;
struct IHDRDefaultTypeInternal;
extern IHDRDefaultTypeInternal _IHDR_default_instance_;
class OtherChunk;
struct OtherChunkDefaultTypeInternal;
extern OtherChunkDefaultTypeInternal _OtherChunk_default_instance_;
class PLTE;
struct PLTEDefaultTypeInternal;
extern PLTEDefaultTypeInternal _PLTE_default_instance_;
class PngChunk;
struct PngChunkDefaultTypeInternal;
extern PngChunkDefaultTypeInternal _PngChunk_default_instance_;
class PngProto;
struct PngProtoDefaultTypeInternal;
extern PngProtoDefaultTypeInternal _PngProto_default_instance_;
class iCCP;
struct iCCPDefaultTypeInternal;
extern iCCPDefaultTypeInternal _iCCP_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::IDAT* Arena::CreateMaybeMessage<::IDAT>(Arena*);
template<> ::IHDR* Arena::CreateMaybeMessage<::IHDR>(Arena*);
template<> ::OtherChunk* Arena::CreateMaybeMessage<::OtherChunk>(Arena*);
template<> ::PLTE* Arena::CreateMaybeMessage<::PLTE>(Arena*);
template<> ::PngChunk* Arena::CreateMaybeMessage<::PngChunk>(Arena*);
template<> ::PngProto* Arena::CreateMaybeMessage<::PngProto>(Arena*);
template<> ::iCCP* Arena::CreateMaybeMessage<::iCCP>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

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

class IHDR final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:IHDR) */ {
 public:
  inline IHDR() : IHDR(nullptr) {}
  ~IHDR() override;
  explicit PROTOBUF_CONSTEXPR IHDR(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  IHDR(const IHDR& from);
  IHDR(IHDR&& from) noexcept
    : IHDR() {
    *this = ::std::move(from);
  }

  inline IHDR& operator=(const IHDR& from) {
    CopyFrom(from);
    return *this;
  }
  inline IHDR& operator=(IHDR&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const IHDR& default_instance() {
    return *internal_default_instance();
  }
  static inline const IHDR* internal_default_instance() {
    return reinterpret_cast<const IHDR*>(
               &_IHDR_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(IHDR& a, IHDR& b) {
    a.Swap(&b);
  }
  inline void Swap(IHDR* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IHDR* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  IHDR* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IHDR>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IHDR& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IHDR& from) {
    IHDR::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IHDR* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "IHDR";
  }
  protected:
  explicit IHDR(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kWidthFieldNumber = 1,
    kHeightFieldNumber = 2,
    kOther1FieldNumber = 3,
    kOther2FieldNumber = 4,
  };
  // required uint32 width = 1;
  bool has_width() const;
  private:
  bool _internal_has_width() const;
  public:
  void clear_width();
  uint32_t width() const;
  void set_width(uint32_t value);
  private:
  uint32_t _internal_width() const;
  void _internal_set_width(uint32_t value);
  public:

  // required uint32 height = 2;
  bool has_height() const;
  private:
  bool _internal_has_height() const;
  public:
  void clear_height();
  uint32_t height() const;
  void set_height(uint32_t value);
  private:
  uint32_t _internal_height() const;
  void _internal_set_height(uint32_t value);
  public:

  // required uint32 other1 = 3;
  bool has_other1() const;
  private:
  bool _internal_has_other1() const;
  public:
  void clear_other1();
  uint32_t other1() const;
  void set_other1(uint32_t value);
  private:
  uint32_t _internal_other1() const;
  void _internal_set_other1(uint32_t value);
  public:

  // required uint32 other2 = 4;
  bool has_other2() const;
  private:
  bool _internal_has_other2() const;
  public:
  void clear_other2();
  uint32_t other2() const;
  void set_other2(uint32_t value);
  private:
  uint32_t _internal_other2() const;
  void _internal_set_other2(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:IHDR)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t width_;
    uint32_t height_;
    uint32_t other1_;
    uint32_t other2_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_png_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

class PLTE final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PLTE) */ {
 public:
  inline PLTE() : PLTE(nullptr) {}
  ~PLTE() override;
  explicit PROTOBUF_CONSTEXPR PLTE(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PLTE(const PLTE& from);
  PLTE(PLTE&& from) noexcept
    : PLTE() {
    *this = ::std::move(from);
  }

  inline PLTE& operator=(const PLTE& from) {
    CopyFrom(from);
    return *this;
  }
  inline PLTE& operator=(PLTE&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PLTE& default_instance() {
    return *internal_default_instance();
  }
  static inline const PLTE* internal_default_instance() {
    return reinterpret_cast<const PLTE*>(
               &_PLTE_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(PLTE& a, PLTE& b) {
    a.Swap(&b);
  }
  inline void Swap(PLTE* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PLTE* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PLTE* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PLTE>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PLTE& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PLTE& from) {
    PLTE::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PLTE* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PLTE";
  }
  protected:
  explicit PLTE(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // required bytes data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  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:PLTE)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_png_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

class IDAT final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:IDAT) */ {
 public:
  inline IDAT() : IDAT(nullptr) {}
  ~IDAT() override;
  explicit PROTOBUF_CONSTEXPR IDAT(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  IDAT(const IDAT& from);
  IDAT(IDAT&& from) noexcept
    : IDAT() {
    *this = ::std::move(from);
  }

  inline IDAT& operator=(const IDAT& from) {
    CopyFrom(from);
    return *this;
  }
  inline IDAT& operator=(IDAT&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const IDAT& default_instance() {
    return *internal_default_instance();
  }
  static inline const IDAT* internal_default_instance() {
    return reinterpret_cast<const IDAT*>(
               &_IDAT_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(IDAT& a, IDAT& b) {
    a.Swap(&b);
  }
  inline void Swap(IDAT* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IDAT* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  IDAT* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IDAT>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IDAT& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IDAT& from) {
    IDAT::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IDAT* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "IDAT";
  }
  protected:
  explicit IDAT(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // required bytes data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  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:IDAT)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_png_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

class iCCP final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:iCCP) */ {
 public:
  inline iCCP() : iCCP(nullptr) {}
  ~iCCP() override;
  explicit PROTOBUF_CONSTEXPR iCCP(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  iCCP(const iCCP& from);
  iCCP(iCCP&& from) noexcept
    : iCCP() {
    *this = ::std::move(from);
  }

  inline iCCP& operator=(const iCCP& from) {
    CopyFrom(from);
    return *this;
  }
  inline iCCP& operator=(iCCP&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const iCCP& default_instance() {
    return *internal_default_instance();
  }
  static inline const iCCP* internal_default_instance() {
    return reinterpret_cast<const iCCP*>(
               &_iCCP_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(iCCP& a, iCCP& b) {
    a.Swap(&b);
  }
  inline void Swap(iCCP* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(iCCP* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  iCCP* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<iCCP>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const iCCP& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const iCCP& from) {
    iCCP::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(iCCP* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "iCCP";
  }
  protected:
  explicit iCCP(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kDataFieldNumber = 2,
  };
  // required bytes data = 2;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  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:iCCP)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_png_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

class OtherChunk final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OtherChunk) */ {
 public:
  inline OtherChunk() : OtherChunk(nullptr) {}
  ~OtherChunk() override;
  explicit PROTOBUF_CONSTEXPR OtherChunk(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  OtherChunk(const OtherChunk& from);
  OtherChunk(OtherChunk&& from) noexcept
    : OtherChunk() {
    *this = ::std::move(from);
  }

  inline OtherChunk& operator=(const OtherChunk& from) {
    CopyFrom(from);
    return *this;
  }
  inline OtherChunk& operator=(OtherChunk&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OtherChunk& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kKnownType = 1,
    kUnknownType = 2,
    TYPE_NOT_SET = 0,
  };

  static inline const OtherChunk* internal_default_instance() {
    return reinterpret_cast<const OtherChunk*>(
               &_OtherChunk_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(OtherChunk& a, OtherChunk& b) {
    a.Swap(&b);
  }
  inline void Swap(OtherChunk* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OtherChunk* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  OtherChunk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OtherChunk>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const OtherChunk& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const OtherChunk& from) {
    OtherChunk::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OtherChunk* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OtherChunk";
  }
  protected:
  explicit OtherChunk(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kDataFieldNumber = 3,
    kKnownTypeFieldNumber = 1,
    kUnknownTypeFieldNumber = 2,
  };
  // required bytes data = 3;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  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:

  // uint32 known_type = 1;
  bool has_known_type() const;
  private:
  bool _internal_has_known_type() const;
  public:
  void clear_known_type();
  uint32_t known_type() const;
  void set_known_type(uint32_t value);
  private:
  uint32_t _internal_known_type() const;
  void _internal_set_known_type(uint32_t value);
  public:

  // uint32 unknown_type = 2;
  bool has_unknown_type() const;
  private:
  bool _internal_has_unknown_type() const;
  public:
  void clear_unknown_type();
  uint32_t unknown_type() const;
  void set_unknown_type(uint32_t value);
  private:
  uint32_t _internal_unknown_type() const;
  void _internal_set_unknown_type(uint32_t value);
  public:

  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:OtherChunk)
 private:
  class _Internal;
  void set_has_known_type();
  void set_has_unknown_type();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      uint32_t known_type_;
      uint32_t unknown_type_;
    } type_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_png_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

class PngChunk final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PngChunk) */ {
 public:
  inline PngChunk() : PngChunk(nullptr) {}
  ~PngChunk() override;
  explicit PROTOBUF_CONSTEXPR PngChunk(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PngChunk(const PngChunk& from);
  PngChunk(PngChunk&& from) noexcept
    : PngChunk() {
    *this = ::std::move(from);
  }

  inline PngChunk& operator=(const PngChunk& from) {
    CopyFrom(from);
    return *this;
  }
  inline PngChunk& operator=(PngChunk&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PngChunk& default_instance() {
    return *internal_default_instance();
  }
  enum ChunkCase {
    kPlte = 1,
    kIdat = 2,
    kIccp = 3,
    kOtherChunk = 10000,
    CHUNK_NOT_SET = 0,
  };

  static inline const PngChunk* internal_default_instance() {
    return reinterpret_cast<const PngChunk*>(
               &_PngChunk_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(PngChunk& a, PngChunk& b) {
    a.Swap(&b);
  }
  inline void Swap(PngChunk* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PngChunk* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PngChunk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PngChunk>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PngChunk& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PngChunk& from) {
    PngChunk::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PngChunk* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PngChunk";
  }
  protected:
  explicit PngChunk(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kPlteFieldNumber = 1,
    kIdatFieldNumber = 2,
    kIccpFieldNumber = 3,
    kOtherChunkFieldNumber = 10000,
  };
  // .PLTE plte = 1;
  bool has_plte() const;
  private:
  bool _internal_has_plte() const;
  public:
  void clear_plte();
  const ::PLTE& plte() const;
  PROTOBUF_NODISCARD ::PLTE* release_plte();
  ::PLTE* mutable_plte();
  void set_allocated_plte(::PLTE* plte);
  private:
  const ::PLTE& _internal_plte() const;
  ::PLTE* _internal_mutable_plte();
  public:
  void unsafe_arena_set_allocated_plte(
      ::PLTE* plte);
  ::PLTE* unsafe_arena_release_plte();

  // .IDAT idat = 2;
  bool has_idat() const;
  private:
  bool _internal_has_idat() const;
  public:
  void clear_idat();
  const ::IDAT& idat() const;
  PROTOBUF_NODISCARD ::IDAT* release_idat();
  ::IDAT* mutable_idat();
  void set_allocated_idat(::IDAT* idat);
  private:
  const ::IDAT& _internal_idat() const;
  ::IDAT* _internal_mutable_idat();
  public:
  void unsafe_arena_set_allocated_idat(
      ::IDAT* idat);
  ::IDAT* unsafe_arena_release_idat();

  // .iCCP iccp = 3;
  bool has_iccp() const;
  private:
  bool _internal_has_iccp() const;
  public:
  void clear_iccp();
  const ::iCCP& iccp() const;
  PROTOBUF_NODISCARD ::iCCP* release_iccp();
  ::iCCP* mutable_iccp();
  void set_allocated_iccp(::iCCP* iccp);
  private:
  const ::iCCP& _internal_iccp() const;
  ::iCCP* _internal_mutable_iccp();
  public:
  void unsafe_arena_set_allocated_iccp(
      ::iCCP* iccp);
  ::iCCP* unsafe_arena_release_iccp();

  // .OtherChunk other_chunk = 10000;
  bool has_other_chunk() const;
  private:
  bool _internal_has_other_chunk() const;
  public:
  void clear_other_chunk();
  const ::OtherChunk& other_chunk() const;
  PROTOBUF_NODISCARD ::OtherChunk* release_other_chunk();
  ::OtherChunk* mutable_other_chunk();
  void set_allocated_other_chunk(::OtherChunk* other_chunk);
  private:
  const ::OtherChunk& _internal_other_chunk() const;
  ::OtherChunk* _internal_mutable_other_chunk();
  public:
  void unsafe_arena_set_allocated_other_chunk(
      ::OtherChunk* other_chunk);
  ::OtherChunk* unsafe_arena_release_other_chunk();

  void clear_chunk();
  ChunkCase chunk_case() const;
  // @@protoc_insertion_point(class_scope:PngChunk)
 private:
  class _Internal;
  void set_has_plte();
  void set_has_idat();
  void set_has_iccp();
  void set_has_other_chunk();

  inline bool has_chunk() const;
  inline void clear_has_chunk();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ChunkUnion {
      constexpr ChunkUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::PLTE* plte_;
      ::IDAT* idat_;
      ::iCCP* iccp_;
      ::OtherChunk* other_chunk_;
    } chunk_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_png_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

class PngProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PngProto) */ {
 public:
  inline PngProto() : PngProto(nullptr) {}
  ~PngProto() override;
  explicit PROTOBUF_CONSTEXPR PngProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PngProto(const PngProto& from);
  PngProto(PngProto&& from) noexcept
    : PngProto() {
    *this = ::std::move(from);
  }

  inline PngProto& operator=(const PngProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline PngProto& operator=(PngProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PngProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const PngProto* internal_default_instance() {
    return reinterpret_cast<const PngProto*>(
               &_PngProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(PngProto& a, PngProto& b) {
    a.Swap(&b);
  }
  inline void Swap(PngProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PngProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PngProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PngProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PngProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PngProto& from) {
    PngProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PngProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PngProto";
  }
  protected:
  explicit PngProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kChunksFieldNumber = 2,
    kIhdrFieldNumber = 1,
  };
  // repeated .PngChunk chunks = 2;
  int chunks_size() const;
  private:
  int _internal_chunks_size() const;
  public:
  void clear_chunks();
  ::PngChunk* mutable_chunks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PngChunk >*
      mutable_chunks();
  private:
  const ::PngChunk& _internal_chunks(int index) const;
  ::PngChunk* _internal_add_chunks();
  public:
  const ::PngChunk& chunks(int index) const;
  ::PngChunk* add_chunks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PngChunk >&
      chunks() const;

  // required .IHDR ihdr = 1;
  bool has_ihdr() const;
  private:
  bool _internal_has_ihdr() const;
  public:
  void clear_ihdr();
  const ::IHDR& ihdr() const;
  PROTOBUF_NODISCARD ::IHDR* release_ihdr();
  ::IHDR* mutable_ihdr();
  void set_allocated_ihdr(::IHDR* ihdr);
  private:
  const ::IHDR& _internal_ihdr() const;
  ::IHDR* _internal_mutable_ihdr();
  public:
  void unsafe_arena_set_allocated_ihdr(
      ::IHDR* ihdr);
  ::IHDR* unsafe_arena_release_ihdr();

  // @@protoc_insertion_point(class_scope:PngProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PngChunk > chunks_;
    ::IHDR* ihdr_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_png_5ffuzz_5fproto_2eproto;
};
// ===================================================================


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

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

// required uint32 width = 1;
inline bool IHDR::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool IHDR::has_width() const {
  return _internal_has_width();
}
inline void IHDR::clear_width() {
  _impl_.width_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t IHDR::_internal_width() const {
  return _impl_.width_;
}
inline uint32_t IHDR::width() const {
  // @@protoc_insertion_point(field_get:IHDR.width)
  return _internal_width();
}
inline void IHDR::_internal_set_width(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.width_ = value;
}
inline void IHDR::set_width(uint32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:IHDR.width)
}

// required uint32 height = 2;
inline bool IHDR::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool IHDR::has_height() const {
  return _internal_has_height();
}
inline void IHDR::clear_height() {
  _impl_.height_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t IHDR::_internal_height() const {
  return _impl_.height_;
}
inline uint32_t IHDR::height() const {
  // @@protoc_insertion_point(field_get:IHDR.height)
  return _internal_height();
}
inline void IHDR::_internal_set_height(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.height_ = value;
}
inline void IHDR::set_height(uint32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:IHDR.height)
}

// required uint32 other1 = 3;
inline bool IHDR::_internal_has_other1() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool IHDR::has_other1() const {
  return _internal_has_other1();
}
inline void IHDR::clear_other1() {
  _impl_.other1_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t IHDR::_internal_other1() const {
  return _impl_.other1_;
}
inline uint32_t IHDR::other1() const {
  // @@protoc_insertion_point(field_get:IHDR.other1)
  return _internal_other1();
}
inline void IHDR::_internal_set_other1(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.other1_ = value;
}
inline void IHDR::set_other1(uint32_t value) {
  _internal_set_other1(value);
  // @@protoc_insertion_point(field_set:IHDR.other1)
}

// required uint32 other2 = 4;
inline bool IHDR::_internal_has_other2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool IHDR::has_other2() const {
  return _internal_has_other2();
}
inline void IHDR::clear_other2() {
  _impl_.other2_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t IHDR::_internal_other2() const {
  return _impl_.other2_;
}
inline uint32_t IHDR::other2() const {
  // @@protoc_insertion_point(field_get:IHDR.other2)
  return _internal_other2();
}
inline void IHDR::_internal_set_other2(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.other2_ = value;
}
inline void IHDR::set_other2(uint32_t value) {
  _internal_set_other2(value);
  // @@protoc_insertion_point(field_set:IHDR.other2)
}

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

// PLTE

// required bytes data = 1;
inline bool PLTE::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PLTE::has_data() const {
  return _internal_has_data();
}
inline void PLTE::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PLTE::data() const {
  // @@protoc_insertion_point(field_get:PLTE.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PLTE::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PLTE.data)
}
inline std::string* PLTE::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:PLTE.data)
  return _s;
}
inline const std::string& PLTE::_internal_data() const {
  return _impl_.data_.Get();
}
inline void PLTE::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* PLTE::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* PLTE::release_data() {
  // @@protoc_insertion_point(field_release:PLTE.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PLTE::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PLTE.data)
}

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

// IDAT

// required bytes data = 1;
inline bool IDAT::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool IDAT::has_data() const {
  return _internal_has_data();
}
inline void IDAT::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& IDAT::data() const {
  // @@protoc_insertion_point(field_get:IDAT.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IDAT::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:IDAT.data)
}
inline std::string* IDAT::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:IDAT.data)
  return _s;
}
inline const std::string& IDAT::_internal_data() const {
  return _impl_.data_.Get();
}
inline void IDAT::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* IDAT::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* IDAT::release_data() {
  // @@protoc_insertion_point(field_release:IDAT.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void IDAT::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:IDAT.data)
}

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

// iCCP

// required bytes data = 2;
inline bool iCCP::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool iCCP::has_data() const {
  return _internal_has_data();
}
inline void iCCP::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& iCCP::data() const {
  // @@protoc_insertion_point(field_get:iCCP.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void iCCP::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:iCCP.data)
}
inline std::string* iCCP::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:iCCP.data)
  return _s;
}
inline const std::string& iCCP::_internal_data() const {
  return _impl_.data_.Get();
}
inline void iCCP::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* iCCP::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* iCCP::release_data() {
  // @@protoc_insertion_point(field_release:iCCP.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void iCCP::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:iCCP.data)
}

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

// OtherChunk

// uint32 known_type = 1;
inline bool OtherChunk::_internal_has_known_type() const {
  return type_case() == kKnownType;
}
inline bool OtherChunk::has_known_type() const {
  return _internal_has_known_type();
}
inline void OtherChunk::set_has_known_type() {
  _impl_._oneof_case_[0] = kKnownType;
}
inline void OtherChunk::clear_known_type() {
  if (_internal_has_known_type()) {
    _impl_.type_.known_type_ = 0u;
    clear_has_type();
  }
}
inline uint32_t OtherChunk::_internal_known_type() const {
  if (_internal_has_known_type()) {
    return _impl_.type_.known_type_;
  }
  return 0u;
}
inline void OtherChunk::_internal_set_known_type(uint32_t value) {
  if (!_internal_has_known_type()) {
    clear_type();
    set_has_known_type();
  }
  _impl_.type_.known_type_ = value;
}
inline uint32_t OtherChunk::known_type() const {
  // @@protoc_insertion_point(field_get:OtherChunk.known_type)
  return _internal_known_type();
}
inline void OtherChunk::set_known_type(uint32_t value) {
  _internal_set_known_type(value);
  // @@protoc_insertion_point(field_set:OtherChunk.known_type)
}

// uint32 unknown_type = 2;
inline bool OtherChunk::_internal_has_unknown_type() const {
  return type_case() == kUnknownType;
}
inline bool OtherChunk::has_unknown_type() const {
  return _internal_has_unknown_type();
}
inline void OtherChunk::set_has_unknown_type() {
  _impl_._oneof_case_[0] = kUnknownType;
}
inline void OtherChunk::clear_unknown_type() {
  if (_internal_has_unknown_type()) {
    _impl_.type_.unknown_type_ = 0u;
    clear_has_type();
  }
}
inline uint32_t OtherChunk::_internal_unknown_type() const {
  if (_internal_has_unknown_type()) {
    return _impl_.type_.unknown_type_;
  }
  return 0u;
}
inline void OtherChunk::_internal_set_unknown_type(uint32_t value) {
  if (!_internal_has_unknown_type()) {
    clear_type();
    set_has_unknown_type();
  }
  _impl_.type_.unknown_type_ = value;
}
inline uint32_t OtherChunk::unknown_type() const {
  // @@protoc_insertion_point(field_get:OtherChunk.unknown_type)
  return _internal_unknown_type();
}
inline void OtherChunk::set_unknown_type(uint32_t value) {
  _internal_set_unknown_type(value);
  // @@protoc_insertion_point(field_set:OtherChunk.unknown_type)
}

// required bytes data = 3;
inline bool OtherChunk::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool OtherChunk::has_data() const {
  return _internal_has_data();
}
inline void OtherChunk::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& OtherChunk::data() const {
  // @@protoc_insertion_point(field_get:OtherChunk.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OtherChunk::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:OtherChunk.data)
}
inline std::string* OtherChunk::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:OtherChunk.data)
  return _s;
}
inline const std::string& OtherChunk::_internal_data() const {
  return _impl_.data_.Get();
}
inline void OtherChunk::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* OtherChunk::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* OtherChunk::release_data() {
  // @@protoc_insertion_point(field_release:OtherChunk.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void OtherChunk::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:OtherChunk.data)
}

inline bool OtherChunk::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void OtherChunk::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline OtherChunk::TypeCase OtherChunk::type_case() const {
  return OtherChunk::TypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// PngChunk

// .PLTE plte = 1;
inline bool PngChunk::_internal_has_plte() const {
  return chunk_case() == kPlte;
}
inline bool PngChunk::has_plte() const {
  return _internal_has_plte();
}
inline void PngChunk::set_has_plte() {
  _impl_._oneof_case_[0] = kPlte;
}
inline void PngChunk::clear_plte() {
  if (_internal_has_plte()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.chunk_.plte_;
    }
    clear_has_chunk();
  }
}
inline ::PLTE* PngChunk::release_plte() {
  // @@protoc_insertion_point(field_release:PngChunk.plte)
  if (_internal_has_plte()) {
    clear_has_chunk();
    ::PLTE* temp = _impl_.chunk_.plte_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.chunk_.plte_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::PLTE& PngChunk::_internal_plte() const {
  return _internal_has_plte()
      ? *_impl_.chunk_.plte_
      : reinterpret_cast< ::PLTE&>(::_PLTE_default_instance_);
}
inline const ::PLTE& PngChunk::plte() const {
  // @@protoc_insertion_point(field_get:PngChunk.plte)
  return _internal_plte();
}
inline ::PLTE* PngChunk::unsafe_arena_release_plte() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PngChunk.plte)
  if (_internal_has_plte()) {
    clear_has_chunk();
    ::PLTE* temp = _impl_.chunk_.plte_;
    _impl_.chunk_.plte_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PngChunk::unsafe_arena_set_allocated_plte(::PLTE* plte) {
  clear_chunk();
  if (plte) {
    set_has_plte();
    _impl_.chunk_.plte_ = plte;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PngChunk.plte)
}
inline ::PLTE* PngChunk::_internal_mutable_plte() {
  if (!_internal_has_plte()) {
    clear_chunk();
    set_has_plte();
    _impl_.chunk_.plte_ = CreateMaybeMessage< ::PLTE >(GetArenaForAllocation());
  }
  return _impl_.chunk_.plte_;
}
inline ::PLTE* PngChunk::mutable_plte() {
  ::PLTE* _msg = _internal_mutable_plte();
  // @@protoc_insertion_point(field_mutable:PngChunk.plte)
  return _msg;
}

// .IDAT idat = 2;
inline bool PngChunk::_internal_has_idat() const {
  return chunk_case() == kIdat;
}
inline bool PngChunk::has_idat() const {
  return _internal_has_idat();
}
inline void PngChunk::set_has_idat() {
  _impl_._oneof_case_[0] = kIdat;
}
inline void PngChunk::clear_idat() {
  if (_internal_has_idat()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.chunk_.idat_;
    }
    clear_has_chunk();
  }
}
inline ::IDAT* PngChunk::release_idat() {
  // @@protoc_insertion_point(field_release:PngChunk.idat)
  if (_internal_has_idat()) {
    clear_has_chunk();
    ::IDAT* temp = _impl_.chunk_.idat_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.chunk_.idat_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::IDAT& PngChunk::_internal_idat() const {
  return _internal_has_idat()
      ? *_impl_.chunk_.idat_
      : reinterpret_cast< ::IDAT&>(::_IDAT_default_instance_);
}
inline const ::IDAT& PngChunk::idat() const {
  // @@protoc_insertion_point(field_get:PngChunk.idat)
  return _internal_idat();
}
inline ::IDAT* PngChunk::unsafe_arena_release_idat() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PngChunk.idat)
  if (_internal_has_idat()) {
    clear_has_chunk();
    ::IDAT* temp = _impl_.chunk_.idat_;
    _impl_.chunk_.idat_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PngChunk::unsafe_arena_set_allocated_idat(::IDAT* idat) {
  clear_chunk();
  if (idat) {
    set_has_idat();
    _impl_.chunk_.idat_ = idat;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PngChunk.idat)
}
inline ::IDAT* PngChunk::_internal_mutable_idat() {
  if (!_internal_has_idat()) {
    clear_chunk();
    set_has_idat();
    _impl_.chunk_.idat_ = CreateMaybeMessage< ::IDAT >(GetArenaForAllocation());
  }
  return _impl_.chunk_.idat_;
}
inline ::IDAT* PngChunk::mutable_idat() {
  ::IDAT* _msg = _internal_mutable_idat();
  // @@protoc_insertion_point(field_mutable:PngChunk.idat)
  return _msg;
}

// .iCCP iccp = 3;
inline bool PngChunk::_internal_has_iccp() const {
  return chunk_case() == kIccp;
}
inline bool PngChunk::has_iccp() const {
  return _internal_has_iccp();
}
inline void PngChunk::set_has_iccp() {
  _impl_._oneof_case_[0] = kIccp;
}
inline void PngChunk::clear_iccp() {
  if (_internal_has_iccp()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.chunk_.iccp_;
    }
    clear_has_chunk();
  }
}
inline ::iCCP* PngChunk::release_iccp() {
  // @@protoc_insertion_point(field_release:PngChunk.iccp)
  if (_internal_has_iccp()) {
    clear_has_chunk();
    ::iCCP* temp = _impl_.chunk_.iccp_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.chunk_.iccp_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::iCCP& PngChunk::_internal_iccp() const {
  return _internal_has_iccp()
      ? *_impl_.chunk_.iccp_
      : reinterpret_cast< ::iCCP&>(::_iCCP_default_instance_);
}
inline const ::iCCP& PngChunk::iccp() const {
  // @@protoc_insertion_point(field_get:PngChunk.iccp)
  return _internal_iccp();
}
inline ::iCCP* PngChunk::unsafe_arena_release_iccp() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PngChunk.iccp)
  if (_internal_has_iccp()) {
    clear_has_chunk();
    ::iCCP* temp = _impl_.chunk_.iccp_;
    _impl_.chunk_.iccp_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PngChunk::unsafe_arena_set_allocated_iccp(::iCCP* iccp) {
  clear_chunk();
  if (iccp) {
    set_has_iccp();
    _impl_.chunk_.iccp_ = iccp;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PngChunk.iccp)
}
inline ::iCCP* PngChunk::_internal_mutable_iccp() {
  if (!_internal_has_iccp()) {
    clear_chunk();
    set_has_iccp();
    _impl_.chunk_.iccp_ = CreateMaybeMessage< ::iCCP >(GetArenaForAllocation());
  }
  return _impl_.chunk_.iccp_;
}
inline ::iCCP* PngChunk::mutable_iccp() {
  ::iCCP* _msg = _internal_mutable_iccp();
  // @@protoc_insertion_point(field_mutable:PngChunk.iccp)
  return _msg;
}

// .OtherChunk other_chunk = 10000;
inline bool PngChunk::_internal_has_other_chunk() const {
  return chunk_case() == kOtherChunk;
}
inline bool PngChunk::has_other_chunk() const {
  return _internal_has_other_chunk();
}
inline void PngChunk::set_has_other_chunk() {
  _impl_._oneof_case_[0] = kOtherChunk;
}
inline void PngChunk::clear_other_chunk() {
  if (_internal_has_other_chunk()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.chunk_.other_chunk_;
    }
    clear_has_chunk();
  }
}
inline ::OtherChunk* PngChunk::release_other_chunk() {
  // @@protoc_insertion_point(field_release:PngChunk.other_chunk)
  if (_internal_has_other_chunk()) {
    clear_has_chunk();
    ::OtherChunk* temp = _impl_.chunk_.other_chunk_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.chunk_.other_chunk_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::OtherChunk& PngChunk::_internal_other_chunk() const {
  return _internal_has_other_chunk()
      ? *_impl_.chunk_.other_chunk_
      : reinterpret_cast< ::OtherChunk&>(::_OtherChunk_default_instance_);
}
inline const ::OtherChunk& PngChunk::other_chunk() const {
  // @@protoc_insertion_point(field_get:PngChunk.other_chunk)
  return _internal_other_chunk();
}
inline ::OtherChunk* PngChunk::unsafe_arena_release_other_chunk() {
  // @@protoc_insertion_point(field_unsafe_arena_release:PngChunk.other_chunk)
  if (_internal_has_other_chunk()) {
    clear_has_chunk();
    ::OtherChunk* temp = _impl_.chunk_.other_chunk_;
    _impl_.chunk_.other_chunk_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PngChunk::unsafe_arena_set_allocated_other_chunk(::OtherChunk* other_chunk) {
  clear_chunk();
  if (other_chunk) {
    set_has_other_chunk();
    _impl_.chunk_.other_chunk_ = other_chunk;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PngChunk.other_chunk)
}
inline ::OtherChunk* PngChunk::_internal_mutable_other_chunk() {
  if (!_internal_has_other_chunk()) {
    clear_chunk();
    set_has_other_chunk();
    _impl_.chunk_.other_chunk_ = CreateMaybeMessage< ::OtherChunk >(GetArenaForAllocation());
  }
  return _impl_.chunk_.other_chunk_;
}
inline ::OtherChunk* PngChunk::mutable_other_chunk() {
  ::OtherChunk* _msg = _internal_mutable_other_chunk();
  // @@protoc_insertion_point(field_mutable:PngChunk.other_chunk)
  return _msg;
}

inline bool PngChunk::has_chunk() const {
  return chunk_case() != CHUNK_NOT_SET;
}
inline void PngChunk::clear_has_chunk() {
  _impl_._oneof_case_[0] = CHUNK_NOT_SET;
}
inline PngChunk::ChunkCase PngChunk::chunk_case() const {
  return PngChunk::ChunkCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// PngProto

// required .IHDR ihdr = 1;
inline bool PngProto::_internal_has_ihdr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ihdr_ != nullptr);
  return value;
}
inline bool PngProto::has_ihdr() const {
  return _internal_has_ihdr();
}
inline void PngProto::clear_ihdr() {
  if (_impl_.ihdr_ != nullptr) _impl_.ihdr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::IHDR& PngProto::_internal_ihdr() const {
  const ::IHDR* p = _impl_.ihdr_;
  return p != nullptr ? *p : reinterpret_cast<const ::IHDR&>(
      ::_IHDR_default_instance_);
}
inline const ::IHDR& PngProto::ihdr() const {
  // @@protoc_insertion_point(field_get:PngProto.ihdr)
  return _internal_ihdr();
}
inline void PngProto::unsafe_arena_set_allocated_ihdr(
    ::IHDR* ihdr) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ihdr_);
  }
  _impl_.ihdr_ = ihdr;
  if (ihdr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PngProto.ihdr)
}
inline ::IHDR* PngProto::release_ihdr() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::IHDR* temp = _impl_.ihdr_;
  _impl_.ihdr_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::IHDR* PngProto::unsafe_arena_release_ihdr() {
  // @@protoc_insertion_point(field_release:PngProto.ihdr)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::IHDR* temp = _impl_.ihdr_;
  _impl_.ihdr_ = nullptr;
  return temp;
}
inline ::IHDR* PngProto::_internal_mutable_ihdr() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.ihdr_ == nullptr) {
    auto* p = CreateMaybeMessage<::IHDR>(GetArenaForAllocation());
    _impl_.ihdr_ = p;
  }
  return _impl_.ihdr_;
}
inline ::IHDR* PngProto::mutable_ihdr() {
  ::IHDR* _msg = _internal_mutable_ihdr();
  // @@protoc_insertion_point(field_mutable:PngProto.ihdr)
  return _msg;
}
inline void PngProto::set_allocated_ihdr(::IHDR* ihdr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.ihdr_;
  }
  if (ihdr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ihdr);
    if (message_arena != submessage_arena) {
      ihdr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ihdr, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.ihdr_ = ihdr;
  // @@protoc_insertion_point(field_set_allocated:PngProto.ihdr)
}

// repeated .PngChunk chunks = 2;
inline int PngProto::_internal_chunks_size() const {
  return _impl_.chunks_.size();
}
inline int PngProto::chunks_size() const {
  return _internal_chunks_size();
}
inline void PngProto::clear_chunks() {
  _impl_.chunks_.Clear();
}
inline ::PngChunk* PngProto::mutable_chunks(int index) {
  // @@protoc_insertion_point(field_mutable:PngProto.chunks)
  return _impl_.chunks_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PngChunk >*
PngProto::mutable_chunks() {
  // @@protoc_insertion_point(field_mutable_list:PngProto.chunks)
  return &_impl_.chunks_;
}
inline const ::PngChunk& PngProto::_internal_chunks(int index) const {
  return _impl_.chunks_.Get(index);
}
inline const ::PngChunk& PngProto::chunks(int index) const {
  // @@protoc_insertion_point(field_get:PngProto.chunks)
  return _internal_chunks(index);
}
inline ::PngChunk* PngProto::_internal_add_chunks() {
  return _impl_.chunks_.Add();
}
inline ::PngChunk* PngProto::add_chunks() {
  ::PngChunk* _add = _internal_add_chunks();
  // @@protoc_insertion_point(field_add:PngProto.chunks)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PngChunk >&
PngProto::chunks() const {
  // @@protoc_insertion_point(field_list:PngProto.chunks)
  return _impl_.chunks_;
}

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_png_5ffuzz_5fproto_2eproto

Coverage Report

Created: 2023-03-17 06:27