/src/genfiles/gif_fuzz_proto.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_gif_5ffuzz_5fproto_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_gif_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_bases.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_gif_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_gif_5ffuzz_5fproto_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_gif_5ffuzz_5fproto_2eproto;
namespace gifProtoFuzzer {
class ApplicationExtension;
struct ApplicationExtensionDefaultTypeInternal;
extern ApplicationExtensionDefaultTypeInternal _ApplicationExtension_default_instance_;
class BasicChunk;
struct BasicChunkDefaultTypeInternal;
extern BasicChunkDefaultTypeInternal _BasicChunk_default_instance_;
class CommentExtension;
struct CommentExtensionDefaultTypeInternal;
extern CommentExtensionDefaultTypeInternal _CommentExtension_default_instance_;
class GifProto;
struct GifProtoDefaultTypeInternal;
extern GifProtoDefaultTypeInternal _GifProto_default_instance_;
class GlobalColorTable;
struct GlobalColorTableDefaultTypeInternal;
extern GlobalColorTableDefaultTypeInternal _GlobalColorTable_default_instance_;
class GraphicControlExtension;
struct GraphicControlExtensionDefaultTypeInternal;
extern GraphicControlExtensionDefaultTypeInternal _GraphicControlExtension_default_instance_;
class Header;
struct HeaderDefaultTypeInternal;
extern HeaderDefaultTypeInternal _Header_default_instance_;
class ImageChunk;
struct ImageChunkDefaultTypeInternal;
extern ImageChunkDefaultTypeInternal _ImageChunk_default_instance_;
class ImageData;
struct ImageDataDefaultTypeInternal;
extern ImageDataDefaultTypeInternal _ImageData_default_instance_;
class ImageDescriptor;
struct ImageDescriptorDefaultTypeInternal;
extern ImageDescriptorDefaultTypeInternal _ImageDescriptor_default_instance_;
class LocalColorTable;
struct LocalColorTableDefaultTypeInternal;
extern LocalColorTableDefaultTypeInternal _LocalColorTable_default_instance_;
class LogicalScreenDescriptor;
struct LogicalScreenDescriptorDefaultTypeInternal;
extern LogicalScreenDescriptorDefaultTypeInternal _LogicalScreenDescriptor_default_instance_;
class PlainTextExtension;
struct PlainTextExtensionDefaultTypeInternal;
extern PlainTextExtensionDefaultTypeInternal _PlainTextExtension_default_instance_;
class SubBlock;
struct SubBlockDefaultTypeInternal;
extern SubBlockDefaultTypeInternal _SubBlock_default_instance_;
class Trailer;
struct TrailerDefaultTypeInternal;
extern TrailerDefaultTypeInternal _Trailer_default_instance_;
}  // namespace gifProtoFuzzer
PROTOBUF_NAMESPACE_OPEN
template<> ::gifProtoFuzzer::ApplicationExtension* Arena::CreateMaybeMessage<::gifProtoFuzzer::ApplicationExtension>(Arena*);
template<> ::gifProtoFuzzer::BasicChunk* Arena::CreateMaybeMessage<::gifProtoFuzzer::BasicChunk>(Arena*);
template<> ::gifProtoFuzzer::CommentExtension* Arena::CreateMaybeMessage<::gifProtoFuzzer::CommentExtension>(Arena*);
template<> ::gifProtoFuzzer::GifProto* Arena::CreateMaybeMessage<::gifProtoFuzzer::GifProto>(Arena*);
template<> ::gifProtoFuzzer::GlobalColorTable* Arena::CreateMaybeMessage<::gifProtoFuzzer::GlobalColorTable>(Arena*);
template<> ::gifProtoFuzzer::GraphicControlExtension* Arena::CreateMaybeMessage<::gifProtoFuzzer::GraphicControlExtension>(Arena*);
template<> ::gifProtoFuzzer::Header* Arena::CreateMaybeMessage<::gifProtoFuzzer::Header>(Arena*);
template<> ::gifProtoFuzzer::ImageChunk* Arena::CreateMaybeMessage<::gifProtoFuzzer::ImageChunk>(Arena*);
template<> ::gifProtoFuzzer::ImageData* Arena::CreateMaybeMessage<::gifProtoFuzzer::ImageData>(Arena*);
template<> ::gifProtoFuzzer::ImageDescriptor* Arena::CreateMaybeMessage<::gifProtoFuzzer::ImageDescriptor>(Arena*);
template<> ::gifProtoFuzzer::LocalColorTable* Arena::CreateMaybeMessage<::gifProtoFuzzer::LocalColorTable>(Arena*);
template<> ::gifProtoFuzzer::LogicalScreenDescriptor* Arena::CreateMaybeMessage<::gifProtoFuzzer::LogicalScreenDescriptor>(Arena*);
template<> ::gifProtoFuzzer::PlainTextExtension* Arena::CreateMaybeMessage<::gifProtoFuzzer::PlainTextExtension>(Arena*);
template<> ::gifProtoFuzzer::SubBlock* Arena::CreateMaybeMessage<::gifProtoFuzzer::SubBlock>(Arena*);
template<> ::gifProtoFuzzer::Trailer* Arena::CreateMaybeMessage<::gifProtoFuzzer::Trailer>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace gifProtoFuzzer {

enum Header_Version : int {
  Header_Version_ENA = 1,
  Header_Version_ESA = 2,
  Header_Version_INV = 3
};
bool Header_Version_IsValid(int value);
constexpr Header_Version Header_Version_Version_MIN = Header_Version_ENA;
constexpr Header_Version Header_Version_Version_MAX = Header_Version_INV;
constexpr int Header_Version_Version_ARRAYSIZE = Header_Version_Version_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Header_Version_descriptor();
template<typename T>
inline const std::string& Header_Version_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Header_Version>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Header_Version_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Header_Version_descriptor(), enum_t_value);
}
inline bool Header_Version_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Header_Version* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Header_Version>(
    Header_Version_descriptor(), name, value);
}
// ===================================================================

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

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

  inline LogicalScreenDescriptor& operator=(const LogicalScreenDescriptor& from) {
    CopyFrom(from);
    return *this;
  }
  inline LogicalScreenDescriptor& operator=(LogicalScreenDescriptor&& 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 LogicalScreenDescriptor& default_instance() {
    return *internal_default_instance();
  }
  static inline const LogicalScreenDescriptor* internal_default_instance() {
    return reinterpret_cast<const LogicalScreenDescriptor*>(
               &_LogicalScreenDescriptor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(LogicalScreenDescriptor& a, LogicalScreenDescriptor& b) {
    a.Swap(&b);
  }
  inline void Swap(LogicalScreenDescriptor* 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(LogicalScreenDescriptor* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LogicalScreenDescriptor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LogicalScreenDescriptor>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LogicalScreenDescriptor& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LogicalScreenDescriptor& from) {
    LogicalScreenDescriptor::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(LogicalScreenDescriptor* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.LogicalScreenDescriptor";
  }
  protected:
  explicit LogicalScreenDescriptor(::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 {
    kScreenWidthFieldNumber = 1,
    kScreenHeightFieldNumber = 2,
    kPackedFieldNumber = 3,
    kBackgroundColorFieldNumber = 4,
    kAspectRatioFieldNumber = 5,
  };
  // required uint32 ScreenWidth = 1;
  bool has_screenwidth() const;
  private:
  bool _internal_has_screenwidth() const;
  public:
  void clear_screenwidth();
  uint32_t screenwidth() const;
  void set_screenwidth(uint32_t value);
  private:
  uint32_t _internal_screenwidth() const;
  void _internal_set_screenwidth(uint32_t value);
  public:

  // required uint32 ScreenHeight = 2;
  bool has_screenheight() const;
  private:
  bool _internal_has_screenheight() const;
  public:
  void clear_screenheight();
  uint32_t screenheight() const;
  void set_screenheight(uint32_t value);
  private:
  uint32_t _internal_screenheight() const;
  void _internal_set_screenheight(uint32_t value);
  public:

  // required uint32 Packed = 3;
  bool has_packed() const;
  private:
  bool _internal_has_packed() const;
  public:
  void clear_packed();
  uint32_t packed() const;
  void set_packed(uint32_t value);
  private:
  uint32_t _internal_packed() const;
  void _internal_set_packed(uint32_t value);
  public:

  // required uint32 BackgroundColor = 4;
  bool has_backgroundcolor() const;
  private:
  bool _internal_has_backgroundcolor() const;
  public:
  void clear_backgroundcolor();
  uint32_t backgroundcolor() const;
  void set_backgroundcolor(uint32_t value);
  private:
  uint32_t _internal_backgroundcolor() const;
  void _internal_set_backgroundcolor(uint32_t value);
  public:

  // required uint32 AspectRatio = 5;
  bool has_aspectratio() const;
  private:
  bool _internal_has_aspectratio() const;
  public:
  void clear_aspectratio();
  uint32_t aspectratio() const;
  void set_aspectratio(uint32_t value);
  private:
  uint32_t _internal_aspectratio() const;
  void _internal_set_aspectratio(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.LogicalScreenDescriptor)
 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 screenwidth_;
    uint32_t screenheight_;
    uint32_t packed_;
    uint32_t backgroundcolor_;
    uint32_t aspectratio_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline GlobalColorTable& operator=(const GlobalColorTable& from) {
    CopyFrom(from);
    return *this;
  }
  inline GlobalColorTable& operator=(GlobalColorTable&& 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 GlobalColorTable& default_instance() {
    return *internal_default_instance();
  }
  static inline const GlobalColorTable* internal_default_instance() {
    return reinterpret_cast<const GlobalColorTable*>(
               &_GlobalColorTable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(GlobalColorTable& a, GlobalColorTable& b) {
    a.Swap(&b);
  }
  inline void Swap(GlobalColorTable* 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(GlobalColorTable* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GlobalColorTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GlobalColorTable>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GlobalColorTable& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const GlobalColorTable& from) {
    GlobalColorTable::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(GlobalColorTable* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.GlobalColorTable";
  }
  protected:
  explicit GlobalColorTable(::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 {
    kColorsFieldNumber = 1,
  };
  // required bytes colors = 1;
  bool has_colors() const;
  private:
  bool _internal_has_colors() const;
  public:
  void clear_colors();
  const std::string& colors() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_colors(ArgT0&& arg0, ArgT... args);
  std::string* mutable_colors();
  PROTOBUF_NODISCARD std::string* release_colors();
  void set_allocated_colors(std::string* colors);
  private:
  const std::string& _internal_colors() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_colors(const std::string& value);
  std::string* _internal_mutable_colors();
  public:

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.GlobalColorTable)
 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 colors_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ImageDescriptor& operator=(const ImageDescriptor& from) {
    CopyFrom(from);
    return *this;
  }
  inline ImageDescriptor& operator=(ImageDescriptor&& 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 ImageDescriptor& default_instance() {
    return *internal_default_instance();
  }
  static inline const ImageDescriptor* internal_default_instance() {
    return reinterpret_cast<const ImageDescriptor*>(
               &_ImageDescriptor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(ImageDescriptor& a, ImageDescriptor& b) {
    a.Swap(&b);
  }
  inline void Swap(ImageDescriptor* 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(ImageDescriptor* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ImageDescriptor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ImageDescriptor>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ImageDescriptor& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ImageDescriptor& from) {
    ImageDescriptor::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(ImageDescriptor* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.ImageDescriptor";
  }
  protected:
  explicit ImageDescriptor(::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 {
    kSeperatorFieldNumber = 1,
    kLeftFieldNumber = 2,
    kTopFieldNumber = 3,
    kWidthFieldNumber = 4,
    kHeightFieldNumber = 5,
    kPackedFieldNumber = 6,
  };
  // required uint32 Seperator = 1;
  bool has_seperator() const;
  private:
  bool _internal_has_seperator() const;
  public:
  void clear_seperator();
  uint32_t seperator() const;
  void set_seperator(uint32_t value);
  private:
  uint32_t _internal_seperator() const;
  void _internal_set_seperator(uint32_t value);
  public:

  // required uint32 Left = 2;
  bool has_left() const;
  private:
  bool _internal_has_left() const;
  public:
  void clear_left();
  uint32_t left() const;
  void set_left(uint32_t value);
  private:
  uint32_t _internal_left() const;
  void _internal_set_left(uint32_t value);
  public:

  // required uint32 Top = 3;
  bool has_top() const;
  private:
  bool _internal_has_top() const;
  public:
  void clear_top();
  uint32_t top() const;
  void set_top(uint32_t value);
  private:
  uint32_t _internal_top() const;
  void _internal_set_top(uint32_t value);
  public:

  // required uint32 Width = 4;
  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 = 5;
  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 Packed = 6;
  bool has_packed() const;
  private:
  bool _internal_has_packed() const;
  public:
  void clear_packed();
  uint32_t packed() const;
  void set_packed(uint32_t value);
  private:
  uint32_t _internal_packed() const;
  void _internal_set_packed(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.ImageDescriptor)
 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 seperator_;
    uint32_t left_;
    uint32_t top_;
    uint32_t width_;
    uint32_t height_;
    uint32_t packed_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline GraphicControlExtension& operator=(const GraphicControlExtension& from) {
    CopyFrom(from);
    return *this;
  }
  inline GraphicControlExtension& operator=(GraphicControlExtension&& 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 GraphicControlExtension& default_instance() {
    return *internal_default_instance();
  }
  static inline const GraphicControlExtension* internal_default_instance() {
    return reinterpret_cast<const GraphicControlExtension*>(
               &_GraphicControlExtension_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(GraphicControlExtension& a, GraphicControlExtension& b) {
    a.Swap(&b);
  }
  inline void Swap(GraphicControlExtension* 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(GraphicControlExtension* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GraphicControlExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GraphicControlExtension>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GraphicControlExtension& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const GraphicControlExtension& from) {
    GraphicControlExtension::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(GraphicControlExtension* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.GraphicControlExtension";
  }
  protected:
  explicit GraphicControlExtension(::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 {
    kPackedFieldNumber = 1,
    kDelayTimeFieldNumber = 2,
    kTransparentColorIndexFieldNumber = 3,
  };
  // required uint32 Packed = 1;
  bool has_packed() const;
  private:
  bool _internal_has_packed() const;
  public:
  void clear_packed();
  uint32_t packed() const;
  void set_packed(uint32_t value);
  private:
  uint32_t _internal_packed() const;
  void _internal_set_packed(uint32_t value);
  public:

  // required uint32 DelayTime = 2;
  bool has_delaytime() const;
  private:
  bool _internal_has_delaytime() const;
  public:
  void clear_delaytime();
  uint32_t delaytime() const;
  void set_delaytime(uint32_t value);
  private:
  uint32_t _internal_delaytime() const;
  void _internal_set_delaytime(uint32_t value);
  public:

  // required uint32 transparentColorIndex = 3;
  bool has_transparentcolorindex() const;
  private:
  bool _internal_has_transparentcolorindex() const;
  public:
  void clear_transparentcolorindex();
  uint32_t transparentcolorindex() const;
  void set_transparentcolorindex(uint32_t value);
  private:
  uint32_t _internal_transparentcolorindex() const;
  void _internal_set_transparentcolorindex(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.GraphicControlExtension)
 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 packed_;
    uint32_t delaytime_;
    uint32_t transparentcolorindex_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline PlainTextExtension& operator=(const PlainTextExtension& from) {
    CopyFrom(from);
    return *this;
  }
  inline PlainTextExtension& operator=(PlainTextExtension&& 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 PlainTextExtension& default_instance() {
    return *internal_default_instance();
  }
  static inline const PlainTextExtension* internal_default_instance() {
    return reinterpret_cast<const PlainTextExtension*>(
               &_PlainTextExtension_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(PlainTextExtension& a, PlainTextExtension& b) {
    a.Swap(&b);
  }
  inline void Swap(PlainTextExtension* 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(PlainTextExtension* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PlainTextExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PlainTextExtension>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PlainTextExtension& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PlainTextExtension& from) {
    PlainTextExtension::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(PlainTextExtension* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.PlainTextExtension";
  }
  protected:
  explicit PlainTextExtension(::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 {
    kSubsFieldNumber = 1,
    kGcExtFieldNumber = 2,
  };
  // repeated .gifProtoFuzzer.SubBlock subs = 1;
  int subs_size() const;
  private:
  int _internal_subs_size() const;
  public:
  void clear_subs();
  ::gifProtoFuzzer::SubBlock* mutable_subs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >*
      mutable_subs();
  private:
  const ::gifProtoFuzzer::SubBlock& _internal_subs(int index) const;
  ::gifProtoFuzzer::SubBlock* _internal_add_subs();
  public:
  const ::gifProtoFuzzer::SubBlock& subs(int index) const;
  ::gifProtoFuzzer::SubBlock* add_subs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >&
      subs() const;

  // optional .gifProtoFuzzer.GraphicControlExtension gcExt = 2;
  bool has_gcext() const;
  private:
  bool _internal_has_gcext() const;
  public:
  void clear_gcext();
  const ::gifProtoFuzzer::GraphicControlExtension& gcext() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::GraphicControlExtension* release_gcext();
  ::gifProtoFuzzer::GraphicControlExtension* mutable_gcext();
  void set_allocated_gcext(::gifProtoFuzzer::GraphicControlExtension* gcext);
  private:
  const ::gifProtoFuzzer::GraphicControlExtension& _internal_gcext() const;
  ::gifProtoFuzzer::GraphicControlExtension* _internal_mutable_gcext();
  public:
  void unsafe_arena_set_allocated_gcext(
      ::gifProtoFuzzer::GraphicControlExtension* gcext);
  ::gifProtoFuzzer::GraphicControlExtension* unsafe_arena_release_gcext();

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.PlainTextExtension)
 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< ::gifProtoFuzzer::SubBlock > subs_;
    ::gifProtoFuzzer::GraphicControlExtension* gcext_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LocalColorTable& operator=(const LocalColorTable& from) {
    CopyFrom(from);
    return *this;
  }
  inline LocalColorTable& operator=(LocalColorTable&& 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 LocalColorTable& default_instance() {
    return *internal_default_instance();
  }
  static inline const LocalColorTable* internal_default_instance() {
    return reinterpret_cast<const LocalColorTable*>(
               &_LocalColorTable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(LocalColorTable& a, LocalColorTable& b) {
    a.Swap(&b);
  }
  inline void Swap(LocalColorTable* 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(LocalColorTable* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LocalColorTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LocalColorTable>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LocalColorTable& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LocalColorTable& from) {
    LocalColorTable::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(LocalColorTable* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.LocalColorTable";
  }
  protected:
  explicit LocalColorTable(::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 {
    kColorsFieldNumber = 1,
  };
  // required bytes colors = 1;
  bool has_colors() const;
  private:
  bool _internal_has_colors() const;
  public:
  void clear_colors();
  const std::string& colors() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_colors(ArgT0&& arg0, ArgT... args);
  std::string* mutable_colors();
  PROTOBUF_NODISCARD std::string* release_colors();
  void set_allocated_colors(std::string* colors);
  private:
  const std::string& _internal_colors() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_colors(const std::string& value);
  std::string* _internal_mutable_colors();
  public:

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.LocalColorTable)
 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 colors_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline SubBlock& operator=(const SubBlock& from) {
    CopyFrom(from);
    return *this;
  }
  inline SubBlock& operator=(SubBlock&& 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 SubBlock& default_instance() {
    return *internal_default_instance();
  }
  static inline const SubBlock* internal_default_instance() {
    return reinterpret_cast<const SubBlock*>(
               &_SubBlock_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(SubBlock& a, SubBlock& b) {
    a.Swap(&b);
  }
  inline void Swap(SubBlock* 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(SubBlock* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SubBlock* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SubBlock>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SubBlock& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SubBlock& from) {
    SubBlock::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(SubBlock* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.SubBlock";
  }
  protected:
  explicit SubBlock(::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,
    kLenFieldNumber = 1,
  };
  // 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:

  // required uint32 len = 1;
  bool has_len() const;
  private:
  bool _internal_has_len() const;
  public:
  void clear_len();
  uint32_t len() const;
  void set_len(uint32_t value);
  private:
  uint32_t _internal_len() const;
  void _internal_set_len(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.SubBlock)
 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_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    uint32_t len_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ImageData& operator=(const ImageData& from) {
    CopyFrom(from);
    return *this;
  }
  inline ImageData& operator=(ImageData&& 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 ImageData& default_instance() {
    return *internal_default_instance();
  }
  static inline const ImageData* internal_default_instance() {
    return reinterpret_cast<const ImageData*>(
               &_ImageData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(ImageData& a, ImageData& b) {
    a.Swap(&b);
  }
  inline void Swap(ImageData* 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(ImageData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ImageData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ImageData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ImageData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ImageData& from) {
    ImageData::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(ImageData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.ImageData";
  }
  protected:
  explicit ImageData(::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 {
    kSubsFieldNumber = 2,
    kLzwFieldNumber = 1,
  };
  // repeated .gifProtoFuzzer.SubBlock subs = 2;
  int subs_size() const;
  private:
  int _internal_subs_size() const;
  public:
  void clear_subs();
  ::gifProtoFuzzer::SubBlock* mutable_subs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >*
      mutable_subs();
  private:
  const ::gifProtoFuzzer::SubBlock& _internal_subs(int index) const;
  ::gifProtoFuzzer::SubBlock* _internal_add_subs();
  public:
  const ::gifProtoFuzzer::SubBlock& subs(int index) const;
  ::gifProtoFuzzer::SubBlock* add_subs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >&
      subs() const;

  // required uint32 lzw = 1;
  bool has_lzw() const;
  private:
  bool _internal_has_lzw() const;
  public:
  void clear_lzw();
  uint32_t lzw() const;
  void set_lzw(uint32_t value);
  private:
  uint32_t _internal_lzw() const;
  void _internal_set_lzw(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.ImageData)
 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< ::gifProtoFuzzer::SubBlock > subs_;
    uint32_t lzw_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline BasicChunk& operator=(const BasicChunk& from) {
    CopyFrom(from);
    return *this;
  }
  inline BasicChunk& operator=(BasicChunk&& 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 BasicChunk& default_instance() {
    return *internal_default_instance();
  }
  static inline const BasicChunk* internal_default_instance() {
    return reinterpret_cast<const BasicChunk*>(
               &_BasicChunk_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(BasicChunk& a, BasicChunk& b) {
    a.Swap(&b);
  }
  inline void Swap(BasicChunk* 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(BasicChunk* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BasicChunk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BasicChunk>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BasicChunk& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BasicChunk& from) {
    BasicChunk::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(BasicChunk* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.BasicChunk";
  }
  protected:
  explicit BasicChunk(::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 {
    kImDescriptorFieldNumber = 1,
    kLctFieldNumber = 2,
    kImgFieldNumber = 3,
    kGcExtFieldNumber = 4,
  };
  // required .gifProtoFuzzer.ImageDescriptor imDescriptor = 1;
  bool has_imdescriptor() const;
  private:
  bool _internal_has_imdescriptor() const;
  public:
  void clear_imdescriptor();
  const ::gifProtoFuzzer::ImageDescriptor& imdescriptor() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::ImageDescriptor* release_imdescriptor();
  ::gifProtoFuzzer::ImageDescriptor* mutable_imdescriptor();
  void set_allocated_imdescriptor(::gifProtoFuzzer::ImageDescriptor* imdescriptor);
  private:
  const ::gifProtoFuzzer::ImageDescriptor& _internal_imdescriptor() const;
  ::gifProtoFuzzer::ImageDescriptor* _internal_mutable_imdescriptor();
  public:
  void unsafe_arena_set_allocated_imdescriptor(
      ::gifProtoFuzzer::ImageDescriptor* imdescriptor);
  ::gifProtoFuzzer::ImageDescriptor* unsafe_arena_release_imdescriptor();

  // required .gifProtoFuzzer.LocalColorTable lct = 2;
  bool has_lct() const;
  private:
  bool _internal_has_lct() const;
  public:
  void clear_lct();
  const ::gifProtoFuzzer::LocalColorTable& lct() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::LocalColorTable* release_lct();
  ::gifProtoFuzzer::LocalColorTable* mutable_lct();
  void set_allocated_lct(::gifProtoFuzzer::LocalColorTable* lct);
  private:
  const ::gifProtoFuzzer::LocalColorTable& _internal_lct() const;
  ::gifProtoFuzzer::LocalColorTable* _internal_mutable_lct();
  public:
  void unsafe_arena_set_allocated_lct(
      ::gifProtoFuzzer::LocalColorTable* lct);
  ::gifProtoFuzzer::LocalColorTable* unsafe_arena_release_lct();

  // required .gifProtoFuzzer.ImageData img = 3;
  bool has_img() const;
  private:
  bool _internal_has_img() const;
  public:
  void clear_img();
  const ::gifProtoFuzzer::ImageData& img() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::ImageData* release_img();
  ::gifProtoFuzzer::ImageData* mutable_img();
  void set_allocated_img(::gifProtoFuzzer::ImageData* img);
  private:
  const ::gifProtoFuzzer::ImageData& _internal_img() const;
  ::gifProtoFuzzer::ImageData* _internal_mutable_img();
  public:
  void unsafe_arena_set_allocated_img(
      ::gifProtoFuzzer::ImageData* img);
  ::gifProtoFuzzer::ImageData* unsafe_arena_release_img();

  // optional .gifProtoFuzzer.GraphicControlExtension gcExt = 4;
  bool has_gcext() const;
  private:
  bool _internal_has_gcext() const;
  public:
  void clear_gcext();
  const ::gifProtoFuzzer::GraphicControlExtension& gcext() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::GraphicControlExtension* release_gcext();
  ::gifProtoFuzzer::GraphicControlExtension* mutable_gcext();
  void set_allocated_gcext(::gifProtoFuzzer::GraphicControlExtension* gcext);
  private:
  const ::gifProtoFuzzer::GraphicControlExtension& _internal_gcext() const;
  ::gifProtoFuzzer::GraphicControlExtension* _internal_mutable_gcext();
  public:
  void unsafe_arena_set_allocated_gcext(
      ::gifProtoFuzzer::GraphicControlExtension* gcext);
  ::gifProtoFuzzer::GraphicControlExtension* unsafe_arena_release_gcext();

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.BasicChunk)
 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_;
    ::gifProtoFuzzer::ImageDescriptor* imdescriptor_;
    ::gifProtoFuzzer::LocalColorTable* lct_;
    ::gifProtoFuzzer::ImageData* img_;
    ::gifProtoFuzzer::GraphicControlExtension* gcext_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ApplicationExtension& operator=(const ApplicationExtension& from) {
    CopyFrom(from);
    return *this;
  }
  inline ApplicationExtension& operator=(ApplicationExtension&& 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 ApplicationExtension& default_instance() {
    return *internal_default_instance();
  }
  static inline const ApplicationExtension* internal_default_instance() {
    return reinterpret_cast<const ApplicationExtension*>(
               &_ApplicationExtension_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(ApplicationExtension& a, ApplicationExtension& b) {
    a.Swap(&b);
  }
  inline void Swap(ApplicationExtension* 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(ApplicationExtension* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ApplicationExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ApplicationExtension>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ApplicationExtension& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ApplicationExtension& from) {
    ApplicationExtension::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(ApplicationExtension* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.ApplicationExtension";
  }
  protected:
  explicit ApplicationExtension(::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 {
    kSubsFieldNumber = 2,
    kAppidFieldNumber = 1,
  };
  // repeated .gifProtoFuzzer.SubBlock subs = 2;
  int subs_size() const;
  private:
  int _internal_subs_size() const;
  public:
  void clear_subs();
  ::gifProtoFuzzer::SubBlock* mutable_subs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >*
      mutable_subs();
  private:
  const ::gifProtoFuzzer::SubBlock& _internal_subs(int index) const;
  ::gifProtoFuzzer::SubBlock* _internal_add_subs();
  public:
  const ::gifProtoFuzzer::SubBlock& subs(int index) const;
  ::gifProtoFuzzer::SubBlock* add_subs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >&
      subs() const;

  // required fixed64 appid = 1;
  bool has_appid() const;
  private:
  bool _internal_has_appid() const;
  public:
  void clear_appid();
  uint64_t appid() const;
  void set_appid(uint64_t value);
  private:
  uint64_t _internal_appid() const;
  void _internal_set_appid(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.ApplicationExtension)
 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< ::gifProtoFuzzer::SubBlock > subs_;
    uint64_t appid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CommentExtension& operator=(const CommentExtension& from) {
    CopyFrom(from);
    return *this;
  }
  inline CommentExtension& operator=(CommentExtension&& 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 CommentExtension& default_instance() {
    return *internal_default_instance();
  }
  static inline const CommentExtension* internal_default_instance() {
    return reinterpret_cast<const CommentExtension*>(
               &_CommentExtension_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(CommentExtension& a, CommentExtension& b) {
    a.Swap(&b);
  }
  inline void Swap(CommentExtension* 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(CommentExtension* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CommentExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CommentExtension>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CommentExtension& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CommentExtension& from) {
    CommentExtension::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(CommentExtension* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.CommentExtension";
  }
  protected:
  explicit CommentExtension(::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 {
    kSubsFieldNumber = 1,
  };
  // repeated .gifProtoFuzzer.SubBlock subs = 1;
  int subs_size() const;
  private:
  int _internal_subs_size() const;
  public:
  void clear_subs();
  ::gifProtoFuzzer::SubBlock* mutable_subs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >*
      mutable_subs();
  private:
  const ::gifProtoFuzzer::SubBlock& _internal_subs(int index) const;
  ::gifProtoFuzzer::SubBlock* _internal_add_subs();
  public:
  const ::gifProtoFuzzer::SubBlock& subs(int index) const;
  ::gifProtoFuzzer::SubBlock* add_subs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >&
      subs() const;

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.CommentExtension)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock > subs_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Header& operator=(const Header& from) {
    CopyFrom(from);
    return *this;
  }
  inline Header& operator=(Header&& 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 Header& default_instance() {
    return *internal_default_instance();
  }
  static inline const Header* internal_default_instance() {
    return reinterpret_cast<const Header*>(
               &_Header_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(Header& a, Header& b) {
    a.Swap(&b);
  }
  inline void Swap(Header* 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(Header* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Header* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Header>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Header& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Header& from) {
    Header::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(Header* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.Header";
  }
  protected:
  explicit Header(::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 ----------------------------------------------------

  typedef Header_Version Version;
  static constexpr Version ENA =
    Header_Version_ENA;
  static constexpr Version ESA =
    Header_Version_ESA;
  static constexpr Version INV =
    Header_Version_INV;
  static inline bool Version_IsValid(int value) {
    return Header_Version_IsValid(value);
  }
  static constexpr Version Version_MIN =
    Header_Version_Version_MIN;
  static constexpr Version Version_MAX =
    Header_Version_Version_MAX;
  static constexpr int Version_ARRAYSIZE =
    Header_Version_Version_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Version_descriptor() {
    return Header_Version_descriptor();
  }
  template<typename T>
  static inline const std::string& Version_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Version>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Version_Name.");
    return Header_Version_Name(enum_t_value);
  }
  static inline bool Version_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Version* value) {
    return Header_Version_Parse(name, value);
  }

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

  enum : int {
    kVerFieldNumber = 1,
  };
  // required .gifProtoFuzzer.Header.Version ver = 1;
  bool has_ver() const;
  private:
  bool _internal_has_ver() const;
  public:
  void clear_ver();
  ::gifProtoFuzzer::Header_Version ver() const;
  void set_ver(::gifProtoFuzzer::Header_Version value);
  private:
  ::gifProtoFuzzer::Header_Version _internal_ver() const;
  void _internal_set_ver(::gifProtoFuzzer::Header_Version value);
  public:

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.Header)
 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_;
    int ver_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

class Trailer final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:gifProtoFuzzer.Trailer) */ {
 public:
  inline Trailer() : Trailer(nullptr) {}
  explicit PROTOBUF_CONSTEXPR Trailer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Trailer& operator=(const Trailer& from) {
    CopyFrom(from);
    return *this;
  }
  inline Trailer& operator=(Trailer&& 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 Trailer& default_instance() {
    return *internal_default_instance();
  }
  static inline const Trailer* internal_default_instance() {
    return reinterpret_cast<const Trailer*>(
               &_Trailer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(Trailer& a, Trailer& b) {
    a.Swap(&b);
  }
  inline void Swap(Trailer* 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(Trailer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Trailer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Trailer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const Trailer& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const Trailer& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.Trailer";
  }
  protected:
  explicit Trailer(::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 -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.Trailer)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ImageChunk& operator=(const ImageChunk& from) {
    CopyFrom(from);
    return *this;
  }
  inline ImageChunk& operator=(ImageChunk&& 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 ImageChunk& default_instance() {
    return *internal_default_instance();
  }
  enum ChunkOneofCase {
    kBasic = 1,
    kPlaintext = 2,
    kAppExt = 3,
    kComExt = 4,
    CHUNK_ONEOF_NOT_SET = 0,
  };

  static inline const ImageChunk* internal_default_instance() {
    return reinterpret_cast<const ImageChunk*>(
               &_ImageChunk_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(ImageChunk& a, ImageChunk& b) {
    a.Swap(&b);
  }
  inline void Swap(ImageChunk* 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(ImageChunk* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ImageChunk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ImageChunk>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ImageChunk& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ImageChunk& from) {
    ImageChunk::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(ImageChunk* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.ImageChunk";
  }
  protected:
  explicit ImageChunk(::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 {
    kBasicFieldNumber = 1,
    kPlaintextFieldNumber = 2,
    kAppExtFieldNumber = 3,
    kComExtFieldNumber = 4,
  };
  // .gifProtoFuzzer.BasicChunk basic = 1;
  bool has_basic() const;
  private:
  bool _internal_has_basic() const;
  public:
  void clear_basic();
  const ::gifProtoFuzzer::BasicChunk& basic() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::BasicChunk* release_basic();
  ::gifProtoFuzzer::BasicChunk* mutable_basic();
  void set_allocated_basic(::gifProtoFuzzer::BasicChunk* basic);
  private:
  const ::gifProtoFuzzer::BasicChunk& _internal_basic() const;
  ::gifProtoFuzzer::BasicChunk* _internal_mutable_basic();
  public:
  void unsafe_arena_set_allocated_basic(
      ::gifProtoFuzzer::BasicChunk* basic);
  ::gifProtoFuzzer::BasicChunk* unsafe_arena_release_basic();

  // .gifProtoFuzzer.PlainTextExtension plaintext = 2;
  bool has_plaintext() const;
  private:
  bool _internal_has_plaintext() const;
  public:
  void clear_plaintext();
  const ::gifProtoFuzzer::PlainTextExtension& plaintext() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::PlainTextExtension* release_plaintext();
  ::gifProtoFuzzer::PlainTextExtension* mutable_plaintext();
  void set_allocated_plaintext(::gifProtoFuzzer::PlainTextExtension* plaintext);
  private:
  const ::gifProtoFuzzer::PlainTextExtension& _internal_plaintext() const;
  ::gifProtoFuzzer::PlainTextExtension* _internal_mutable_plaintext();
  public:
  void unsafe_arena_set_allocated_plaintext(
      ::gifProtoFuzzer::PlainTextExtension* plaintext);
  ::gifProtoFuzzer::PlainTextExtension* unsafe_arena_release_plaintext();

  // .gifProtoFuzzer.ApplicationExtension appExt = 3;
  bool has_appext() const;
  private:
  bool _internal_has_appext() const;
  public:
  void clear_appext();
  const ::gifProtoFuzzer::ApplicationExtension& appext() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::ApplicationExtension* release_appext();
  ::gifProtoFuzzer::ApplicationExtension* mutable_appext();
  void set_allocated_appext(::gifProtoFuzzer::ApplicationExtension* appext);
  private:
  const ::gifProtoFuzzer::ApplicationExtension& _internal_appext() const;
  ::gifProtoFuzzer::ApplicationExtension* _internal_mutable_appext();
  public:
  void unsafe_arena_set_allocated_appext(
      ::gifProtoFuzzer::ApplicationExtension* appext);
  ::gifProtoFuzzer::ApplicationExtension* unsafe_arena_release_appext();

  // .gifProtoFuzzer.CommentExtension comExt = 4;
  bool has_comext() const;
  private:
  bool _internal_has_comext() const;
  public:
  void clear_comext();
  const ::gifProtoFuzzer::CommentExtension& comext() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::CommentExtension* release_comext();
  ::gifProtoFuzzer::CommentExtension* mutable_comext();
  void set_allocated_comext(::gifProtoFuzzer::CommentExtension* comext);
  private:
  const ::gifProtoFuzzer::CommentExtension& _internal_comext() const;
  ::gifProtoFuzzer::CommentExtension* _internal_mutable_comext();
  public:
  void unsafe_arena_set_allocated_comext(
      ::gifProtoFuzzer::CommentExtension* comext);
  ::gifProtoFuzzer::CommentExtension* unsafe_arena_release_comext();

  void clear_chunk_oneof();
  ChunkOneofCase chunk_oneof_case() const;
  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.ImageChunk)
 private:
  class _Internal;
  void set_has_basic();
  void set_has_plaintext();
  void set_has_appext();
  void set_has_comext();

  inline bool has_chunk_oneof() const;
  inline void clear_has_chunk_oneof();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ChunkOneofUnion {
      constexpr ChunkOneofUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::gifProtoFuzzer::BasicChunk* basic_;
      ::gifProtoFuzzer::PlainTextExtension* plaintext_;
      ::gifProtoFuzzer::ApplicationExtension* appext_;
      ::gifProtoFuzzer::CommentExtension* comext_;
    } chunk_oneof_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

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

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

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

  inline GifProto& operator=(const GifProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline GifProto& operator=(GifProto&& 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 GifProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const GifProto* internal_default_instance() {
    return reinterpret_cast<const GifProto*>(
               &_GifProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(GifProto& a, GifProto& b) {
    a.Swap(&b);
  }
  inline void Swap(GifProto* 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(GifProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GifProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GifProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GifProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const GifProto& from) {
    GifProto::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(GifProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gifProtoFuzzer.GifProto";
  }
  protected:
  explicit GifProto(::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 = 4,
    kHeaderFieldNumber = 1,
    kLsdFieldNumber = 2,
    kGctFieldNumber = 3,
    kTrailerFieldNumber = 5,
  };
  // repeated .gifProtoFuzzer.ImageChunk chunks = 4;
  int chunks_size() const;
  private:
  int _internal_chunks_size() const;
  public:
  void clear_chunks();
  ::gifProtoFuzzer::ImageChunk* mutable_chunks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::ImageChunk >*
      mutable_chunks();
  private:
  const ::gifProtoFuzzer::ImageChunk& _internal_chunks(int index) const;
  ::gifProtoFuzzer::ImageChunk* _internal_add_chunks();
  public:
  const ::gifProtoFuzzer::ImageChunk& chunks(int index) const;
  ::gifProtoFuzzer::ImageChunk* add_chunks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::ImageChunk >&
      chunks() const;

  // required .gifProtoFuzzer.Header header = 1;
  bool has_header() const;
  private:
  bool _internal_has_header() const;
  public:
  void clear_header();
  const ::gifProtoFuzzer::Header& header() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::Header* release_header();
  ::gifProtoFuzzer::Header* mutable_header();
  void set_allocated_header(::gifProtoFuzzer::Header* header);
  private:
  const ::gifProtoFuzzer::Header& _internal_header() const;
  ::gifProtoFuzzer::Header* _internal_mutable_header();
  public:
  void unsafe_arena_set_allocated_header(
      ::gifProtoFuzzer::Header* header);
  ::gifProtoFuzzer::Header* unsafe_arena_release_header();

  // required .gifProtoFuzzer.LogicalScreenDescriptor lsd = 2;
  bool has_lsd() const;
  private:
  bool _internal_has_lsd() const;
  public:
  void clear_lsd();
  const ::gifProtoFuzzer::LogicalScreenDescriptor& lsd() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::LogicalScreenDescriptor* release_lsd();
  ::gifProtoFuzzer::LogicalScreenDescriptor* mutable_lsd();
  void set_allocated_lsd(::gifProtoFuzzer::LogicalScreenDescriptor* lsd);
  private:
  const ::gifProtoFuzzer::LogicalScreenDescriptor& _internal_lsd() const;
  ::gifProtoFuzzer::LogicalScreenDescriptor* _internal_mutable_lsd();
  public:
  void unsafe_arena_set_allocated_lsd(
      ::gifProtoFuzzer::LogicalScreenDescriptor* lsd);
  ::gifProtoFuzzer::LogicalScreenDescriptor* unsafe_arena_release_lsd();

  // required .gifProtoFuzzer.GlobalColorTable gct = 3;
  bool has_gct() const;
  private:
  bool _internal_has_gct() const;
  public:
  void clear_gct();
  const ::gifProtoFuzzer::GlobalColorTable& gct() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::GlobalColorTable* release_gct();
  ::gifProtoFuzzer::GlobalColorTable* mutable_gct();
  void set_allocated_gct(::gifProtoFuzzer::GlobalColorTable* gct);
  private:
  const ::gifProtoFuzzer::GlobalColorTable& _internal_gct() const;
  ::gifProtoFuzzer::GlobalColorTable* _internal_mutable_gct();
  public:
  void unsafe_arena_set_allocated_gct(
      ::gifProtoFuzzer::GlobalColorTable* gct);
  ::gifProtoFuzzer::GlobalColorTable* unsafe_arena_release_gct();

  // required .gifProtoFuzzer.Trailer trailer = 5;
  bool has_trailer() const;
  private:
  bool _internal_has_trailer() const;
  public:
  void clear_trailer();
  const ::gifProtoFuzzer::Trailer& trailer() const;
  PROTOBUF_NODISCARD ::gifProtoFuzzer::Trailer* release_trailer();
  ::gifProtoFuzzer::Trailer* mutable_trailer();
  void set_allocated_trailer(::gifProtoFuzzer::Trailer* trailer);
  private:
  const ::gifProtoFuzzer::Trailer& _internal_trailer() const;
  ::gifProtoFuzzer::Trailer* _internal_mutable_trailer();
  public:
  void unsafe_arena_set_allocated_trailer(
      ::gifProtoFuzzer::Trailer* trailer);
  ::gifProtoFuzzer::Trailer* unsafe_arena_release_trailer();

  // @@protoc_insertion_point(class_scope:gifProtoFuzzer.GifProto)
 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_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::ImageChunk > chunks_;
    ::gifProtoFuzzer::Header* header_;
    ::gifProtoFuzzer::LogicalScreenDescriptor* lsd_;
    ::gifProtoFuzzer::GlobalColorTable* gct_;
    ::gifProtoFuzzer::Trailer* trailer_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gif_5ffuzz_5fproto_2eproto;
};
// ===================================================================


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

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

// required uint32 ScreenWidth = 1;
inline bool LogicalScreenDescriptor::_internal_has_screenwidth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LogicalScreenDescriptor::has_screenwidth() const {
  return _internal_has_screenwidth();
}
inline void LogicalScreenDescriptor::clear_screenwidth() {
  _impl_.screenwidth_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t LogicalScreenDescriptor::_internal_screenwidth() const {
  return _impl_.screenwidth_;
}
inline uint32_t LogicalScreenDescriptor::screenwidth() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.LogicalScreenDescriptor.ScreenWidth)
  return _internal_screenwidth();
}
inline void LogicalScreenDescriptor::_internal_set_screenwidth(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.screenwidth_ = value;
}
inline void LogicalScreenDescriptor::set_screenwidth(uint32_t value) {
  _internal_set_screenwidth(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.LogicalScreenDescriptor.ScreenWidth)
}

// required uint32 ScreenHeight = 2;
inline bool LogicalScreenDescriptor::_internal_has_screenheight() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LogicalScreenDescriptor::has_screenheight() const {
  return _internal_has_screenheight();
}
inline void LogicalScreenDescriptor::clear_screenheight() {
  _impl_.screenheight_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t LogicalScreenDescriptor::_internal_screenheight() const {
  return _impl_.screenheight_;
}
inline uint32_t LogicalScreenDescriptor::screenheight() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.LogicalScreenDescriptor.ScreenHeight)
  return _internal_screenheight();
}
inline void LogicalScreenDescriptor::_internal_set_screenheight(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.screenheight_ = value;
}
inline void LogicalScreenDescriptor::set_screenheight(uint32_t value) {
  _internal_set_screenheight(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.LogicalScreenDescriptor.ScreenHeight)
}

// required uint32 Packed = 3;
inline bool LogicalScreenDescriptor::_internal_has_packed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LogicalScreenDescriptor::has_packed() const {
  return _internal_has_packed();
}
inline void LogicalScreenDescriptor::clear_packed() {
  _impl_.packed_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t LogicalScreenDescriptor::_internal_packed() const {
  return _impl_.packed_;
}
inline uint32_t LogicalScreenDescriptor::packed() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.LogicalScreenDescriptor.Packed)
  return _internal_packed();
}
inline void LogicalScreenDescriptor::_internal_set_packed(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.packed_ = value;
}
inline void LogicalScreenDescriptor::set_packed(uint32_t value) {
  _internal_set_packed(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.LogicalScreenDescriptor.Packed)
}

// required uint32 BackgroundColor = 4;
inline bool LogicalScreenDescriptor::_internal_has_backgroundcolor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool LogicalScreenDescriptor::has_backgroundcolor() const {
  return _internal_has_backgroundcolor();
}
inline void LogicalScreenDescriptor::clear_backgroundcolor() {
  _impl_.backgroundcolor_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t LogicalScreenDescriptor::_internal_backgroundcolor() const {
  return _impl_.backgroundcolor_;
}
inline uint32_t LogicalScreenDescriptor::backgroundcolor() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.LogicalScreenDescriptor.BackgroundColor)
  return _internal_backgroundcolor();
}
inline void LogicalScreenDescriptor::_internal_set_backgroundcolor(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.backgroundcolor_ = value;
}
inline void LogicalScreenDescriptor::set_backgroundcolor(uint32_t value) {
  _internal_set_backgroundcolor(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.LogicalScreenDescriptor.BackgroundColor)
}

// required uint32 AspectRatio = 5;
inline bool LogicalScreenDescriptor::_internal_has_aspectratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool LogicalScreenDescriptor::has_aspectratio() const {
  return _internal_has_aspectratio();
}
inline void LogicalScreenDescriptor::clear_aspectratio() {
  _impl_.aspectratio_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t LogicalScreenDescriptor::_internal_aspectratio() const {
  return _impl_.aspectratio_;
}
inline uint32_t LogicalScreenDescriptor::aspectratio() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.LogicalScreenDescriptor.AspectRatio)
  return _internal_aspectratio();
}
inline void LogicalScreenDescriptor::_internal_set_aspectratio(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.aspectratio_ = value;
}
inline void LogicalScreenDescriptor::set_aspectratio(uint32_t value) {
  _internal_set_aspectratio(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.LogicalScreenDescriptor.AspectRatio)
}

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

// GlobalColorTable

// required bytes colors = 1;
inline bool GlobalColorTable::_internal_has_colors() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GlobalColorTable::has_colors() const {
  return _internal_has_colors();
}
inline void GlobalColorTable::clear_colors() {
  _impl_.colors_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GlobalColorTable::colors() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.GlobalColorTable.colors)
  return _internal_colors();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GlobalColorTable::set_colors(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.colors_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.GlobalColorTable.colors)
}
inline std::string* GlobalColorTable::mutable_colors() {
  std::string* _s = _internal_mutable_colors();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.GlobalColorTable.colors)
  return _s;
}
inline const std::string& GlobalColorTable::_internal_colors() const {
  return _impl_.colors_.Get();
}
inline void GlobalColorTable::_internal_set_colors(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.colors_.Set(value, GetArenaForAllocation());
}
inline std::string* GlobalColorTable::_internal_mutable_colors() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.colors_.Mutable(GetArenaForAllocation());
}
inline std::string* GlobalColorTable::release_colors() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.GlobalColorTable.colors)
  if (!_internal_has_colors()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.colors_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.colors_.IsDefault()) {
    _impl_.colors_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GlobalColorTable::set_allocated_colors(std::string* colors) {
  if (colors != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.colors_.SetAllocated(colors, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.colors_.IsDefault()) {
    _impl_.colors_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:gifProtoFuzzer.GlobalColorTable.colors)
}

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

// ImageDescriptor

// required uint32 Seperator = 1;
inline bool ImageDescriptor::_internal_has_seperator() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ImageDescriptor::has_seperator() const {
  return _internal_has_seperator();
}
inline void ImageDescriptor::clear_seperator() {
  _impl_.seperator_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t ImageDescriptor::_internal_seperator() const {
  return _impl_.seperator_;
}
inline uint32_t ImageDescriptor::seperator() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ImageDescriptor.Seperator)
  return _internal_seperator();
}
inline void ImageDescriptor::_internal_set_seperator(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.seperator_ = value;
}
inline void ImageDescriptor::set_seperator(uint32_t value) {
  _internal_set_seperator(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.ImageDescriptor.Seperator)
}

// required uint32 Left = 2;
inline bool ImageDescriptor::_internal_has_left() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ImageDescriptor::has_left() const {
  return _internal_has_left();
}
inline void ImageDescriptor::clear_left() {
  _impl_.left_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t ImageDescriptor::_internal_left() const {
  return _impl_.left_;
}
inline uint32_t ImageDescriptor::left() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ImageDescriptor.Left)
  return _internal_left();
}
inline void ImageDescriptor::_internal_set_left(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.left_ = value;
}
inline void ImageDescriptor::set_left(uint32_t value) {
  _internal_set_left(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.ImageDescriptor.Left)
}

// required uint32 Top = 3;
inline bool ImageDescriptor::_internal_has_top() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ImageDescriptor::has_top() const {
  return _internal_has_top();
}
inline void ImageDescriptor::clear_top() {
  _impl_.top_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t ImageDescriptor::_internal_top() const {
  return _impl_.top_;
}
inline uint32_t ImageDescriptor::top() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ImageDescriptor.Top)
  return _internal_top();
}
inline void ImageDescriptor::_internal_set_top(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.top_ = value;
}
inline void ImageDescriptor::set_top(uint32_t value) {
  _internal_set_top(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.ImageDescriptor.Top)
}

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

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

// required uint32 Packed = 6;
inline bool ImageDescriptor::_internal_has_packed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ImageDescriptor::has_packed() const {
  return _internal_has_packed();
}
inline void ImageDescriptor::clear_packed() {
  _impl_.packed_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t ImageDescriptor::_internal_packed() const {
  return _impl_.packed_;
}
inline uint32_t ImageDescriptor::packed() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ImageDescriptor.Packed)
  return _internal_packed();
}
inline void ImageDescriptor::_internal_set_packed(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.packed_ = value;
}
inline void ImageDescriptor::set_packed(uint32_t value) {
  _internal_set_packed(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.ImageDescriptor.Packed)
}

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

// GraphicControlExtension

// required uint32 Packed = 1;
inline bool GraphicControlExtension::_internal_has_packed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GraphicControlExtension::has_packed() const {
  return _internal_has_packed();
}
inline void GraphicControlExtension::clear_packed() {
  _impl_.packed_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t GraphicControlExtension::_internal_packed() const {
  return _impl_.packed_;
}
inline uint32_t GraphicControlExtension::packed() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.GraphicControlExtension.Packed)
  return _internal_packed();
}
inline void GraphicControlExtension::_internal_set_packed(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.packed_ = value;
}
inline void GraphicControlExtension::set_packed(uint32_t value) {
  _internal_set_packed(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.GraphicControlExtension.Packed)
}

// required uint32 DelayTime = 2;
inline bool GraphicControlExtension::_internal_has_delaytime() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool GraphicControlExtension::has_delaytime() const {
  return _internal_has_delaytime();
}
inline void GraphicControlExtension::clear_delaytime() {
  _impl_.delaytime_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t GraphicControlExtension::_internal_delaytime() const {
  return _impl_.delaytime_;
}
inline uint32_t GraphicControlExtension::delaytime() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.GraphicControlExtension.DelayTime)
  return _internal_delaytime();
}
inline void GraphicControlExtension::_internal_set_delaytime(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.delaytime_ = value;
}
inline void GraphicControlExtension::set_delaytime(uint32_t value) {
  _internal_set_delaytime(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.GraphicControlExtension.DelayTime)
}

// required uint32 transparentColorIndex = 3;
inline bool GraphicControlExtension::_internal_has_transparentcolorindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool GraphicControlExtension::has_transparentcolorindex() const {
  return _internal_has_transparentcolorindex();
}
inline void GraphicControlExtension::clear_transparentcolorindex() {
  _impl_.transparentcolorindex_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t GraphicControlExtension::_internal_transparentcolorindex() const {
  return _impl_.transparentcolorindex_;
}
inline uint32_t GraphicControlExtension::transparentcolorindex() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.GraphicControlExtension.transparentColorIndex)
  return _internal_transparentcolorindex();
}
inline void GraphicControlExtension::_internal_set_transparentcolorindex(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.transparentcolorindex_ = value;
}
inline void GraphicControlExtension::set_transparentcolorindex(uint32_t value) {
  _internal_set_transparentcolorindex(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.GraphicControlExtension.transparentColorIndex)
}

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

// PlainTextExtension

// repeated .gifProtoFuzzer.SubBlock subs = 1;
inline int PlainTextExtension::_internal_subs_size() const {
  return _impl_.subs_.size();
}
inline int PlainTextExtension::subs_size() const {
  return _internal_subs_size();
}
inline void PlainTextExtension::clear_subs() {
  _impl_.subs_.Clear();
}
inline ::gifProtoFuzzer::SubBlock* PlainTextExtension::mutable_subs(int index) {
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.PlainTextExtension.subs)
  return _impl_.subs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >*
PlainTextExtension::mutable_subs() {
  // @@protoc_insertion_point(field_mutable_list:gifProtoFuzzer.PlainTextExtension.subs)
  return &_impl_.subs_;
}
inline const ::gifProtoFuzzer::SubBlock& PlainTextExtension::_internal_subs(int index) const {
  return _impl_.subs_.Get(index);
}
inline const ::gifProtoFuzzer::SubBlock& PlainTextExtension::subs(int index) const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.PlainTextExtension.subs)
  return _internal_subs(index);
}
inline ::gifProtoFuzzer::SubBlock* PlainTextExtension::_internal_add_subs() {
  return _impl_.subs_.Add();
}
inline ::gifProtoFuzzer::SubBlock* PlainTextExtension::add_subs() {
  ::gifProtoFuzzer::SubBlock* _add = _internal_add_subs();
  // @@protoc_insertion_point(field_add:gifProtoFuzzer.PlainTextExtension.subs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >&
PlainTextExtension::subs() const {
  // @@protoc_insertion_point(field_list:gifProtoFuzzer.PlainTextExtension.subs)
  return _impl_.subs_;
}

// optional .gifProtoFuzzer.GraphicControlExtension gcExt = 2;
inline bool PlainTextExtension::_internal_has_gcext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.gcext_ != nullptr);
  return value;
}
inline bool PlainTextExtension::has_gcext() const {
  return _internal_has_gcext();
}
inline void PlainTextExtension::clear_gcext() {
  if (_impl_.gcext_ != nullptr) _impl_.gcext_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::gifProtoFuzzer::GraphicControlExtension& PlainTextExtension::_internal_gcext() const {
  const ::gifProtoFuzzer::GraphicControlExtension* p = _impl_.gcext_;
  return p != nullptr ? *p : reinterpret_cast<const ::gifProtoFuzzer::GraphicControlExtension&>(
      ::gifProtoFuzzer::_GraphicControlExtension_default_instance_);
}
inline const ::gifProtoFuzzer::GraphicControlExtension& PlainTextExtension::gcext() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.PlainTextExtension.gcExt)
  return _internal_gcext();
}
inline void PlainTextExtension::unsafe_arena_set_allocated_gcext(
    ::gifProtoFuzzer::GraphicControlExtension* gcext) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.gcext_);
  }
  _impl_.gcext_ = gcext;
  if (gcext) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.PlainTextExtension.gcExt)
}
inline ::gifProtoFuzzer::GraphicControlExtension* PlainTextExtension::release_gcext() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::gifProtoFuzzer::GraphicControlExtension* temp = _impl_.gcext_;
  _impl_.gcext_ = 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 ::gifProtoFuzzer::GraphicControlExtension* PlainTextExtension::unsafe_arena_release_gcext() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.PlainTextExtension.gcExt)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::gifProtoFuzzer::GraphicControlExtension* temp = _impl_.gcext_;
  _impl_.gcext_ = nullptr;
  return temp;
}
inline ::gifProtoFuzzer::GraphicControlExtension* PlainTextExtension::_internal_mutable_gcext() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.gcext_ == nullptr) {
    auto* p = CreateMaybeMessage<::gifProtoFuzzer::GraphicControlExtension>(GetArenaForAllocation());
    _impl_.gcext_ = p;
  }
  return _impl_.gcext_;
}
inline ::gifProtoFuzzer::GraphicControlExtension* PlainTextExtension::mutable_gcext() {
  ::gifProtoFuzzer::GraphicControlExtension* _msg = _internal_mutable_gcext();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.PlainTextExtension.gcExt)
  return _msg;
}
inline void PlainTextExtension::set_allocated_gcext(::gifProtoFuzzer::GraphicControlExtension* gcext) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.gcext_;
  }
  if (gcext) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(gcext);
    if (message_arena != submessage_arena) {
      gcext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, gcext, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.gcext_ = gcext;
  // @@protoc_insertion_point(field_set_allocated:gifProtoFuzzer.PlainTextExtension.gcExt)
}

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

// LocalColorTable

// required bytes colors = 1;
inline bool LocalColorTable::_internal_has_colors() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LocalColorTable::has_colors() const {
  return _internal_has_colors();
}
inline void LocalColorTable::clear_colors() {
  _impl_.colors_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LocalColorTable::colors() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.LocalColorTable.colors)
  return _internal_colors();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalColorTable::set_colors(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.colors_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.LocalColorTable.colors)
}
inline std::string* LocalColorTable::mutable_colors() {
  std::string* _s = _internal_mutable_colors();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.LocalColorTable.colors)
  return _s;
}
inline const std::string& LocalColorTable::_internal_colors() const {
  return _impl_.colors_.Get();
}
inline void LocalColorTable::_internal_set_colors(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.colors_.Set(value, GetArenaForAllocation());
}
inline std::string* LocalColorTable::_internal_mutable_colors() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.colors_.Mutable(GetArenaForAllocation());
}
inline std::string* LocalColorTable::release_colors() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.LocalColorTable.colors)
  if (!_internal_has_colors()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.colors_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.colors_.IsDefault()) {
    _impl_.colors_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LocalColorTable::set_allocated_colors(std::string* colors) {
  if (colors != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.colors_.SetAllocated(colors, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.colors_.IsDefault()) {
    _impl_.colors_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:gifProtoFuzzer.LocalColorTable.colors)
}

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

// SubBlock

// required uint32 len = 1;
inline bool SubBlock::_internal_has_len() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SubBlock::has_len() const {
  return _internal_has_len();
}
inline void SubBlock::clear_len() {
  _impl_.len_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t SubBlock::_internal_len() const {
  return _impl_.len_;
}
inline uint32_t SubBlock::len() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.SubBlock.len)
  return _internal_len();
}
inline void SubBlock::_internal_set_len(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.len_ = value;
}
inline void SubBlock::set_len(uint32_t value) {
  _internal_set_len(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.SubBlock.len)
}

// required bytes data = 2;
inline bool SubBlock::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SubBlock::has_data() const {
  return _internal_has_data();
}
inline void SubBlock::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SubBlock::data() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.SubBlock.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SubBlock::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:gifProtoFuzzer.SubBlock.data)
}
inline std::string* SubBlock::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.SubBlock.data)
  return _s;
}
inline const std::string& SubBlock::_internal_data() const {
  return _impl_.data_.Get();
}
inline void SubBlock::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* SubBlock::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* SubBlock::release_data() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.SubBlock.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 SubBlock::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:gifProtoFuzzer.SubBlock.data)
}

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

// ImageData

// required uint32 lzw = 1;
inline bool ImageData::_internal_has_lzw() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ImageData::has_lzw() const {
  return _internal_has_lzw();
}
inline void ImageData::clear_lzw() {
  _impl_.lzw_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t ImageData::_internal_lzw() const {
  return _impl_.lzw_;
}
inline uint32_t ImageData::lzw() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ImageData.lzw)
  return _internal_lzw();
}
inline void ImageData::_internal_set_lzw(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.lzw_ = value;
}
inline void ImageData::set_lzw(uint32_t value) {
  _internal_set_lzw(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.ImageData.lzw)
}

// repeated .gifProtoFuzzer.SubBlock subs = 2;
inline int ImageData::_internal_subs_size() const {
  return _impl_.subs_.size();
}
inline int ImageData::subs_size() const {
  return _internal_subs_size();
}
inline void ImageData::clear_subs() {
  _impl_.subs_.Clear();
}
inline ::gifProtoFuzzer::SubBlock* ImageData::mutable_subs(int index) {
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.ImageData.subs)
  return _impl_.subs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >*
ImageData::mutable_subs() {
  // @@protoc_insertion_point(field_mutable_list:gifProtoFuzzer.ImageData.subs)
  return &_impl_.subs_;
}
inline const ::gifProtoFuzzer::SubBlock& ImageData::_internal_subs(int index) const {
  return _impl_.subs_.Get(index);
}
inline const ::gifProtoFuzzer::SubBlock& ImageData::subs(int index) const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ImageData.subs)
  return _internal_subs(index);
}
inline ::gifProtoFuzzer::SubBlock* ImageData::_internal_add_subs() {
  return _impl_.subs_.Add();
}
inline ::gifProtoFuzzer::SubBlock* ImageData::add_subs() {
  ::gifProtoFuzzer::SubBlock* _add = _internal_add_subs();
  // @@protoc_insertion_point(field_add:gifProtoFuzzer.ImageData.subs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >&
ImageData::subs() const {
  // @@protoc_insertion_point(field_list:gifProtoFuzzer.ImageData.subs)
  return _impl_.subs_;
}

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

// BasicChunk

// required .gifProtoFuzzer.ImageDescriptor imDescriptor = 1;
inline bool BasicChunk::_internal_has_imdescriptor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.imdescriptor_ != nullptr);
  return value;
}
inline bool BasicChunk::has_imdescriptor() const {
  return _internal_has_imdescriptor();
}
inline void BasicChunk::clear_imdescriptor() {
  if (_impl_.imdescriptor_ != nullptr) _impl_.imdescriptor_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::gifProtoFuzzer::ImageDescriptor& BasicChunk::_internal_imdescriptor() const {
  const ::gifProtoFuzzer::ImageDescriptor* p = _impl_.imdescriptor_;
  return p != nullptr ? *p : reinterpret_cast<const ::gifProtoFuzzer::ImageDescriptor&>(
      ::gifProtoFuzzer::_ImageDescriptor_default_instance_);
}
inline const ::gifProtoFuzzer::ImageDescriptor& BasicChunk::imdescriptor() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.BasicChunk.imDescriptor)
  return _internal_imdescriptor();
}
inline void BasicChunk::unsafe_arena_set_allocated_imdescriptor(
    ::gifProtoFuzzer::ImageDescriptor* imdescriptor) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.imdescriptor_);
  }
  _impl_.imdescriptor_ = imdescriptor;
  if (imdescriptor) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.BasicChunk.imDescriptor)
}
inline ::gifProtoFuzzer::ImageDescriptor* BasicChunk::release_imdescriptor() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::gifProtoFuzzer::ImageDescriptor* temp = _impl_.imdescriptor_;
  _impl_.imdescriptor_ = 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 ::gifProtoFuzzer::ImageDescriptor* BasicChunk::unsafe_arena_release_imdescriptor() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.BasicChunk.imDescriptor)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::gifProtoFuzzer::ImageDescriptor* temp = _impl_.imdescriptor_;
  _impl_.imdescriptor_ = nullptr;
  return temp;
}
inline ::gifProtoFuzzer::ImageDescriptor* BasicChunk::_internal_mutable_imdescriptor() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.imdescriptor_ == nullptr) {
    auto* p = CreateMaybeMessage<::gifProtoFuzzer::ImageDescriptor>(GetArenaForAllocation());
    _impl_.imdescriptor_ = p;
  }
  return _impl_.imdescriptor_;
}
inline ::gifProtoFuzzer::ImageDescriptor* BasicChunk::mutable_imdescriptor() {
  ::gifProtoFuzzer::ImageDescriptor* _msg = _internal_mutable_imdescriptor();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.BasicChunk.imDescriptor)
  return _msg;
}
inline void BasicChunk::set_allocated_imdescriptor(::gifProtoFuzzer::ImageDescriptor* imdescriptor) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.imdescriptor_;
  }
  if (imdescriptor) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imdescriptor);
    if (message_arena != submessage_arena) {
      imdescriptor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, imdescriptor, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.imdescriptor_ = imdescriptor;
  // @@protoc_insertion_point(field_set_allocated:gifProtoFuzzer.BasicChunk.imDescriptor)
}

// required .gifProtoFuzzer.LocalColorTable lct = 2;
inline bool BasicChunk::_internal_has_lct() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.lct_ != nullptr);
  return value;
}
inline bool BasicChunk::has_lct() const {
  return _internal_has_lct();
}
inline void BasicChunk::clear_lct() {
  if (_impl_.lct_ != nullptr) _impl_.lct_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::gifProtoFuzzer::LocalColorTable& BasicChunk::_internal_lct() const {
  const ::gifProtoFuzzer::LocalColorTable* p = _impl_.lct_;
  return p != nullptr ? *p : reinterpret_cast<const ::gifProtoFuzzer::LocalColorTable&>(
      ::gifProtoFuzzer::_LocalColorTable_default_instance_);
}
inline const ::gifProtoFuzzer::LocalColorTable& BasicChunk::lct() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.BasicChunk.lct)
  return _internal_lct();
}
inline void BasicChunk::unsafe_arena_set_allocated_lct(
    ::gifProtoFuzzer::LocalColorTable* lct) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lct_);
  }
  _impl_.lct_ = lct;
  if (lct) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.BasicChunk.lct)
}
inline ::gifProtoFuzzer::LocalColorTable* BasicChunk::release_lct() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::gifProtoFuzzer::LocalColorTable* temp = _impl_.lct_;
  _impl_.lct_ = 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 ::gifProtoFuzzer::LocalColorTable* BasicChunk::unsafe_arena_release_lct() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.BasicChunk.lct)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::gifProtoFuzzer::LocalColorTable* temp = _impl_.lct_;
  _impl_.lct_ = nullptr;
  return temp;
}
inline ::gifProtoFuzzer::LocalColorTable* BasicChunk::_internal_mutable_lct() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.lct_ == nullptr) {
    auto* p = CreateMaybeMessage<::gifProtoFuzzer::LocalColorTable>(GetArenaForAllocation());
    _impl_.lct_ = p;
  }
  return _impl_.lct_;
}
inline ::gifProtoFuzzer::LocalColorTable* BasicChunk::mutable_lct() {
  ::gifProtoFuzzer::LocalColorTable* _msg = _internal_mutable_lct();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.BasicChunk.lct)
  return _msg;
}
inline void BasicChunk::set_allocated_lct(::gifProtoFuzzer::LocalColorTable* lct) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.lct_;
  }
  if (lct) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lct);
    if (message_arena != submessage_arena) {
      lct = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lct, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.lct_ = lct;
  // @@protoc_insertion_point(field_set_allocated:gifProtoFuzzer.BasicChunk.lct)
}

// required .gifProtoFuzzer.ImageData img = 3;
inline bool BasicChunk::_internal_has_img() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.img_ != nullptr);
  return value;
}
inline bool BasicChunk::has_img() const {
  return _internal_has_img();
}
inline void BasicChunk::clear_img() {
  if (_impl_.img_ != nullptr) _impl_.img_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::gifProtoFuzzer::ImageData& BasicChunk::_internal_img() const {
  const ::gifProtoFuzzer::ImageData* p = _impl_.img_;
  return p != nullptr ? *p : reinterpret_cast<const ::gifProtoFuzzer::ImageData&>(
      ::gifProtoFuzzer::_ImageData_default_instance_);
}
inline const ::gifProtoFuzzer::ImageData& BasicChunk::img() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.BasicChunk.img)
  return _internal_img();
}
inline void BasicChunk::unsafe_arena_set_allocated_img(
    ::gifProtoFuzzer::ImageData* img) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.img_);
  }
  _impl_.img_ = img;
  if (img) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.BasicChunk.img)
}
inline ::gifProtoFuzzer::ImageData* BasicChunk::release_img() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::gifProtoFuzzer::ImageData* temp = _impl_.img_;
  _impl_.img_ = 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 ::gifProtoFuzzer::ImageData* BasicChunk::unsafe_arena_release_img() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.BasicChunk.img)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::gifProtoFuzzer::ImageData* temp = _impl_.img_;
  _impl_.img_ = nullptr;
  return temp;
}
inline ::gifProtoFuzzer::ImageData* BasicChunk::_internal_mutable_img() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.img_ == nullptr) {
    auto* p = CreateMaybeMessage<::gifProtoFuzzer::ImageData>(GetArenaForAllocation());
    _impl_.img_ = p;
  }
  return _impl_.img_;
}
inline ::gifProtoFuzzer::ImageData* BasicChunk::mutable_img() {
  ::gifProtoFuzzer::ImageData* _msg = _internal_mutable_img();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.BasicChunk.img)
  return _msg;
}
inline void BasicChunk::set_allocated_img(::gifProtoFuzzer::ImageData* img) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.img_;
  }
  if (img) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(img);
    if (message_arena != submessage_arena) {
      img = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, img, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.img_ = img;
  // @@protoc_insertion_point(field_set_allocated:gifProtoFuzzer.BasicChunk.img)
}

// optional .gifProtoFuzzer.GraphicControlExtension gcExt = 4;
inline bool BasicChunk::_internal_has_gcext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.gcext_ != nullptr);
  return value;
}
inline bool BasicChunk::has_gcext() const {
  return _internal_has_gcext();
}
inline void BasicChunk::clear_gcext() {
  if (_impl_.gcext_ != nullptr) _impl_.gcext_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::gifProtoFuzzer::GraphicControlExtension& BasicChunk::_internal_gcext() const {
  const ::gifProtoFuzzer::GraphicControlExtension* p = _impl_.gcext_;
  return p != nullptr ? *p : reinterpret_cast<const ::gifProtoFuzzer::GraphicControlExtension&>(
      ::gifProtoFuzzer::_GraphicControlExtension_default_instance_);
}
inline const ::gifProtoFuzzer::GraphicControlExtension& BasicChunk::gcext() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.BasicChunk.gcExt)
  return _internal_gcext();
}
inline void BasicChunk::unsafe_arena_set_allocated_gcext(
    ::gifProtoFuzzer::GraphicControlExtension* gcext) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.gcext_);
  }
  _impl_.gcext_ = gcext;
  if (gcext) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.BasicChunk.gcExt)
}
inline ::gifProtoFuzzer::GraphicControlExtension* BasicChunk::release_gcext() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::gifProtoFuzzer::GraphicControlExtension* temp = _impl_.gcext_;
  _impl_.gcext_ = 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 ::gifProtoFuzzer::GraphicControlExtension* BasicChunk::unsafe_arena_release_gcext() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.BasicChunk.gcExt)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::gifProtoFuzzer::GraphicControlExtension* temp = _impl_.gcext_;
  _impl_.gcext_ = nullptr;
  return temp;
}
inline ::gifProtoFuzzer::GraphicControlExtension* BasicChunk::_internal_mutable_gcext() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.gcext_ == nullptr) {
    auto* p = CreateMaybeMessage<::gifProtoFuzzer::GraphicControlExtension>(GetArenaForAllocation());
    _impl_.gcext_ = p;
  }
  return _impl_.gcext_;
}
inline ::gifProtoFuzzer::GraphicControlExtension* BasicChunk::mutable_gcext() {
  ::gifProtoFuzzer::GraphicControlExtension* _msg = _internal_mutable_gcext();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.BasicChunk.gcExt)
  return _msg;
}
inline void BasicChunk::set_allocated_gcext(::gifProtoFuzzer::GraphicControlExtension* gcext) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.gcext_;
  }
  if (gcext) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(gcext);
    if (message_arena != submessage_arena) {
      gcext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, gcext, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.gcext_ = gcext;
  // @@protoc_insertion_point(field_set_allocated:gifProtoFuzzer.BasicChunk.gcExt)
}

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

// ApplicationExtension

// required fixed64 appid = 1;
inline bool ApplicationExtension::_internal_has_appid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ApplicationExtension::has_appid() const {
  return _internal_has_appid();
}
inline void ApplicationExtension::clear_appid() {
  _impl_.appid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t ApplicationExtension::_internal_appid() const {
  return _impl_.appid_;
}
inline uint64_t ApplicationExtension::appid() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ApplicationExtension.appid)
  return _internal_appid();
}
inline void ApplicationExtension::_internal_set_appid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.appid_ = value;
}
inline void ApplicationExtension::set_appid(uint64_t value) {
  _internal_set_appid(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.ApplicationExtension.appid)
}

// repeated .gifProtoFuzzer.SubBlock subs = 2;
inline int ApplicationExtension::_internal_subs_size() const {
  return _impl_.subs_.size();
}
inline int ApplicationExtension::subs_size() const {
  return _internal_subs_size();
}
inline void ApplicationExtension::clear_subs() {
  _impl_.subs_.Clear();
}
inline ::gifProtoFuzzer::SubBlock* ApplicationExtension::mutable_subs(int index) {
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.ApplicationExtension.subs)
  return _impl_.subs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >*
ApplicationExtension::mutable_subs() {
  // @@protoc_insertion_point(field_mutable_list:gifProtoFuzzer.ApplicationExtension.subs)
  return &_impl_.subs_;
}
inline const ::gifProtoFuzzer::SubBlock& ApplicationExtension::_internal_subs(int index) const {
  return _impl_.subs_.Get(index);
}
inline const ::gifProtoFuzzer::SubBlock& ApplicationExtension::subs(int index) const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ApplicationExtension.subs)
  return _internal_subs(index);
}
inline ::gifProtoFuzzer::SubBlock* ApplicationExtension::_internal_add_subs() {
  return _impl_.subs_.Add();
}
inline ::gifProtoFuzzer::SubBlock* ApplicationExtension::add_subs() {
  ::gifProtoFuzzer::SubBlock* _add = _internal_add_subs();
  // @@protoc_insertion_point(field_add:gifProtoFuzzer.ApplicationExtension.subs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >&
ApplicationExtension::subs() const {
  // @@protoc_insertion_point(field_list:gifProtoFuzzer.ApplicationExtension.subs)
  return _impl_.subs_;
}

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

// CommentExtension

// repeated .gifProtoFuzzer.SubBlock subs = 1;
inline int CommentExtension::_internal_subs_size() const {
  return _impl_.subs_.size();
}
inline int CommentExtension::subs_size() const {
  return _internal_subs_size();
}
inline void CommentExtension::clear_subs() {
  _impl_.subs_.Clear();
}
inline ::gifProtoFuzzer::SubBlock* CommentExtension::mutable_subs(int index) {
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.CommentExtension.subs)
  return _impl_.subs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >*
CommentExtension::mutable_subs() {
  // @@protoc_insertion_point(field_mutable_list:gifProtoFuzzer.CommentExtension.subs)
  return &_impl_.subs_;
}
inline const ::gifProtoFuzzer::SubBlock& CommentExtension::_internal_subs(int index) const {
  return _impl_.subs_.Get(index);
}
inline const ::gifProtoFuzzer::SubBlock& CommentExtension::subs(int index) const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.CommentExtension.subs)
  return _internal_subs(index);
}
inline ::gifProtoFuzzer::SubBlock* CommentExtension::_internal_add_subs() {
  return _impl_.subs_.Add();
}
inline ::gifProtoFuzzer::SubBlock* CommentExtension::add_subs() {
  ::gifProtoFuzzer::SubBlock* _add = _internal_add_subs();
  // @@protoc_insertion_point(field_add:gifProtoFuzzer.CommentExtension.subs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gifProtoFuzzer::SubBlock >&
CommentExtension::subs() const {
  // @@protoc_insertion_point(field_list:gifProtoFuzzer.CommentExtension.subs)
  return _impl_.subs_;
}

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

// Header

// required .gifProtoFuzzer.Header.Version ver = 1;
inline bool Header::_internal_has_ver() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Header::has_ver() const {
  return _internal_has_ver();
}
inline void Header::clear_ver() {
  _impl_.ver_ = 1;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::gifProtoFuzzer::Header_Version Header::_internal_ver() const {
  return static_cast< ::gifProtoFuzzer::Header_Version >(_impl_.ver_);
}
inline ::gifProtoFuzzer::Header_Version Header::ver() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.Header.ver)
  return _internal_ver();
}
inline void Header::_internal_set_ver(::gifProtoFuzzer::Header_Version value) {
  assert(::gifProtoFuzzer::Header_Version_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ver_ = value;
}
inline void Header::set_ver(::gifProtoFuzzer::Header_Version value) {
  _internal_set_ver(value);
  // @@protoc_insertion_point(field_set:gifProtoFuzzer.Header.ver)
}

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

// Trailer

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

// ImageChunk

// .gifProtoFuzzer.BasicChunk basic = 1;
inline bool ImageChunk::_internal_has_basic() const {
  return chunk_oneof_case() == kBasic;
}
inline bool ImageChunk::has_basic() const {
  return _internal_has_basic();
}
inline void ImageChunk::set_has_basic() {
  _impl_._oneof_case_[0] = kBasic;
}
inline void ImageChunk::clear_basic() {
  if (_internal_has_basic()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.chunk_oneof_.basic_;
    }
    clear_has_chunk_oneof();
  }
}
inline ::gifProtoFuzzer::BasicChunk* ImageChunk::release_basic() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.ImageChunk.basic)
  if (_internal_has_basic()) {
    clear_has_chunk_oneof();
    ::gifProtoFuzzer::BasicChunk* temp = _impl_.chunk_oneof_.basic_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.chunk_oneof_.basic_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::gifProtoFuzzer::BasicChunk& ImageChunk::_internal_basic() const {
  return _internal_has_basic()
      ? *_impl_.chunk_oneof_.basic_
      : reinterpret_cast< ::gifProtoFuzzer::BasicChunk&>(::gifProtoFuzzer::_BasicChunk_default_instance_);
}
inline const ::gifProtoFuzzer::BasicChunk& ImageChunk::basic() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ImageChunk.basic)
  return _internal_basic();
}
inline ::gifProtoFuzzer::BasicChunk* ImageChunk::unsafe_arena_release_basic() {
  // @@protoc_insertion_point(field_unsafe_arena_release:gifProtoFuzzer.ImageChunk.basic)
  if (_internal_has_basic()) {
    clear_has_chunk_oneof();
    ::gifProtoFuzzer::BasicChunk* temp = _impl_.chunk_oneof_.basic_;
    _impl_.chunk_oneof_.basic_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ImageChunk::unsafe_arena_set_allocated_basic(::gifProtoFuzzer::BasicChunk* basic) {
  clear_chunk_oneof();
  if (basic) {
    set_has_basic();
    _impl_.chunk_oneof_.basic_ = basic;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.ImageChunk.basic)
}
inline ::gifProtoFuzzer::BasicChunk* ImageChunk::_internal_mutable_basic() {
  if (!_internal_has_basic()) {
    clear_chunk_oneof();
    set_has_basic();
    _impl_.chunk_oneof_.basic_ = CreateMaybeMessage< ::gifProtoFuzzer::BasicChunk >(GetArenaForAllocation());
  }
  return _impl_.chunk_oneof_.basic_;
}
inline ::gifProtoFuzzer::BasicChunk* ImageChunk::mutable_basic() {
  ::gifProtoFuzzer::BasicChunk* _msg = _internal_mutable_basic();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.ImageChunk.basic)
  return _msg;
}

// .gifProtoFuzzer.PlainTextExtension plaintext = 2;
inline bool ImageChunk::_internal_has_plaintext() const {
  return chunk_oneof_case() == kPlaintext;
}
inline bool ImageChunk::has_plaintext() const {
  return _internal_has_plaintext();
}
inline void ImageChunk::set_has_plaintext() {
  _impl_._oneof_case_[0] = kPlaintext;
}
inline void ImageChunk::clear_plaintext() {
  if (_internal_has_plaintext()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.chunk_oneof_.plaintext_;
    }
    clear_has_chunk_oneof();
  }
}
inline ::gifProtoFuzzer::PlainTextExtension* ImageChunk::release_plaintext() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.ImageChunk.plaintext)
  if (_internal_has_plaintext()) {
    clear_has_chunk_oneof();
    ::gifProtoFuzzer::PlainTextExtension* temp = _impl_.chunk_oneof_.plaintext_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.chunk_oneof_.plaintext_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::gifProtoFuzzer::PlainTextExtension& ImageChunk::_internal_plaintext() const {
  return _internal_has_plaintext()
      ? *_impl_.chunk_oneof_.plaintext_
      : reinterpret_cast< ::gifProtoFuzzer::PlainTextExtension&>(::gifProtoFuzzer::_PlainTextExtension_default_instance_);
}
inline const ::gifProtoFuzzer::PlainTextExtension& ImageChunk::plaintext() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ImageChunk.plaintext)
  return _internal_plaintext();
}
inline ::gifProtoFuzzer::PlainTextExtension* ImageChunk::unsafe_arena_release_plaintext() {
  // @@protoc_insertion_point(field_unsafe_arena_release:gifProtoFuzzer.ImageChunk.plaintext)
  if (_internal_has_plaintext()) {
    clear_has_chunk_oneof();
    ::gifProtoFuzzer::PlainTextExtension* temp = _impl_.chunk_oneof_.plaintext_;
    _impl_.chunk_oneof_.plaintext_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ImageChunk::unsafe_arena_set_allocated_plaintext(::gifProtoFuzzer::PlainTextExtension* plaintext) {
  clear_chunk_oneof();
  if (plaintext) {
    set_has_plaintext();
    _impl_.chunk_oneof_.plaintext_ = plaintext;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.ImageChunk.plaintext)
}
inline ::gifProtoFuzzer::PlainTextExtension* ImageChunk::_internal_mutable_plaintext() {
  if (!_internal_has_plaintext()) {
    clear_chunk_oneof();
    set_has_plaintext();
    _impl_.chunk_oneof_.plaintext_ = CreateMaybeMessage< ::gifProtoFuzzer::PlainTextExtension >(GetArenaForAllocation());
  }
  return _impl_.chunk_oneof_.plaintext_;
}
inline ::gifProtoFuzzer::PlainTextExtension* ImageChunk::mutable_plaintext() {
  ::gifProtoFuzzer::PlainTextExtension* _msg = _internal_mutable_plaintext();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.ImageChunk.plaintext)
  return _msg;
}

// .gifProtoFuzzer.ApplicationExtension appExt = 3;
inline bool ImageChunk::_internal_has_appext() const {
  return chunk_oneof_case() == kAppExt;
}
inline bool ImageChunk::has_appext() const {
  return _internal_has_appext();
}
inline void ImageChunk::set_has_appext() {
  _impl_._oneof_case_[0] = kAppExt;
}
inline void ImageChunk::clear_appext() {
  if (_internal_has_appext()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.chunk_oneof_.appext_;
    }
    clear_has_chunk_oneof();
  }
}
inline ::gifProtoFuzzer::ApplicationExtension* ImageChunk::release_appext() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.ImageChunk.appExt)
  if (_internal_has_appext()) {
    clear_has_chunk_oneof();
    ::gifProtoFuzzer::ApplicationExtension* temp = _impl_.chunk_oneof_.appext_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.chunk_oneof_.appext_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::gifProtoFuzzer::ApplicationExtension& ImageChunk::_internal_appext() const {
  return _internal_has_appext()
      ? *_impl_.chunk_oneof_.appext_
      : reinterpret_cast< ::gifProtoFuzzer::ApplicationExtension&>(::gifProtoFuzzer::_ApplicationExtension_default_instance_);
}
inline const ::gifProtoFuzzer::ApplicationExtension& ImageChunk::appext() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ImageChunk.appExt)
  return _internal_appext();
}
inline ::gifProtoFuzzer::ApplicationExtension* ImageChunk::unsafe_arena_release_appext() {
  // @@protoc_insertion_point(field_unsafe_arena_release:gifProtoFuzzer.ImageChunk.appExt)
  if (_internal_has_appext()) {
    clear_has_chunk_oneof();
    ::gifProtoFuzzer::ApplicationExtension* temp = _impl_.chunk_oneof_.appext_;
    _impl_.chunk_oneof_.appext_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ImageChunk::unsafe_arena_set_allocated_appext(::gifProtoFuzzer::ApplicationExtension* appext) {
  clear_chunk_oneof();
  if (appext) {
    set_has_appext();
    _impl_.chunk_oneof_.appext_ = appext;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.ImageChunk.appExt)
}
inline ::gifProtoFuzzer::ApplicationExtension* ImageChunk::_internal_mutable_appext() {
  if (!_internal_has_appext()) {
    clear_chunk_oneof();
    set_has_appext();
    _impl_.chunk_oneof_.appext_ = CreateMaybeMessage< ::gifProtoFuzzer::ApplicationExtension >(GetArenaForAllocation());
  }
  return _impl_.chunk_oneof_.appext_;
}
inline ::gifProtoFuzzer::ApplicationExtension* ImageChunk::mutable_appext() {
  ::gifProtoFuzzer::ApplicationExtension* _msg = _internal_mutable_appext();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.ImageChunk.appExt)
  return _msg;
}

// .gifProtoFuzzer.CommentExtension comExt = 4;
inline bool ImageChunk::_internal_has_comext() const {
  return chunk_oneof_case() == kComExt;
}
inline bool ImageChunk::has_comext() const {
  return _internal_has_comext();
}
inline void ImageChunk::set_has_comext() {
  _impl_._oneof_case_[0] = kComExt;
}
inline void ImageChunk::clear_comext() {
  if (_internal_has_comext()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.chunk_oneof_.comext_;
    }
    clear_has_chunk_oneof();
  }
}
inline ::gifProtoFuzzer::CommentExtension* ImageChunk::release_comext() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.ImageChunk.comExt)
  if (_internal_has_comext()) {
    clear_has_chunk_oneof();
    ::gifProtoFuzzer::CommentExtension* temp = _impl_.chunk_oneof_.comext_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.chunk_oneof_.comext_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::gifProtoFuzzer::CommentExtension& ImageChunk::_internal_comext() const {
  return _internal_has_comext()
      ? *_impl_.chunk_oneof_.comext_
      : reinterpret_cast< ::gifProtoFuzzer::CommentExtension&>(::gifProtoFuzzer::_CommentExtension_default_instance_);
}
inline const ::gifProtoFuzzer::CommentExtension& ImageChunk::comext() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.ImageChunk.comExt)
  return _internal_comext();
}
inline ::gifProtoFuzzer::CommentExtension* ImageChunk::unsafe_arena_release_comext() {
  // @@protoc_insertion_point(field_unsafe_arena_release:gifProtoFuzzer.ImageChunk.comExt)
  if (_internal_has_comext()) {
    clear_has_chunk_oneof();
    ::gifProtoFuzzer::CommentExtension* temp = _impl_.chunk_oneof_.comext_;
    _impl_.chunk_oneof_.comext_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ImageChunk::unsafe_arena_set_allocated_comext(::gifProtoFuzzer::CommentExtension* comext) {
  clear_chunk_oneof();
  if (comext) {
    set_has_comext();
    _impl_.chunk_oneof_.comext_ = comext;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.ImageChunk.comExt)
}
inline ::gifProtoFuzzer::CommentExtension* ImageChunk::_internal_mutable_comext() {
  if (!_internal_has_comext()) {
    clear_chunk_oneof();
    set_has_comext();
    _impl_.chunk_oneof_.comext_ = CreateMaybeMessage< ::gifProtoFuzzer::CommentExtension >(GetArenaForAllocation());
  }
  return _impl_.chunk_oneof_.comext_;
}
inline ::gifProtoFuzzer::CommentExtension* ImageChunk::mutable_comext() {
  ::gifProtoFuzzer::CommentExtension* _msg = _internal_mutable_comext();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.ImageChunk.comExt)
  return _msg;
}

inline bool ImageChunk::has_chunk_oneof() const {
  return chunk_oneof_case() != CHUNK_ONEOF_NOT_SET;
}
inline void ImageChunk::clear_has_chunk_oneof() {
  _impl_._oneof_case_[0] = CHUNK_ONEOF_NOT_SET;
}
inline ImageChunk::ChunkOneofCase ImageChunk::chunk_oneof_case() const {
  return ImageChunk::ChunkOneofCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GifProto

// required .gifProtoFuzzer.Header header = 1;
inline bool GifProto::_internal_has_header() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr);
  return value;
}
inline bool GifProto::has_header() const {
  return _internal_has_header();
}
inline void GifProto::clear_header() {
  if (_impl_.header_ != nullptr) _impl_.header_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::gifProtoFuzzer::Header& GifProto::_internal_header() const {
  const ::gifProtoFuzzer::Header* p = _impl_.header_;
  return p != nullptr ? *p : reinterpret_cast<const ::gifProtoFuzzer::Header&>(
      ::gifProtoFuzzer::_Header_default_instance_);
}
inline const ::gifProtoFuzzer::Header& GifProto::header() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.GifProto.header)
  return _internal_header();
}
inline void GifProto::unsafe_arena_set_allocated_header(
    ::gifProtoFuzzer::Header* header) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_);
  }
  _impl_.header_ = header;
  if (header) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.GifProto.header)
}
inline ::gifProtoFuzzer::Header* GifProto::release_header() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::gifProtoFuzzer::Header* temp = _impl_.header_;
  _impl_.header_ = 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 ::gifProtoFuzzer::Header* GifProto::unsafe_arena_release_header() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.GifProto.header)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::gifProtoFuzzer::Header* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::gifProtoFuzzer::Header* GifProto::_internal_mutable_header() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.header_ == nullptr) {
    auto* p = CreateMaybeMessage<::gifProtoFuzzer::Header>(GetArenaForAllocation());
    _impl_.header_ = p;
  }
  return _impl_.header_;
}
inline ::gifProtoFuzzer::Header* GifProto::mutable_header() {
  ::gifProtoFuzzer::Header* _msg = _internal_mutable_header();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.GifProto.header)
  return _msg;
}
inline void GifProto::set_allocated_header(::gifProtoFuzzer::Header* header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.header_;
  }
  if (header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(header);
    if (message_arena != submessage_arena) {
      header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, header, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.header_ = header;
  // @@protoc_insertion_point(field_set_allocated:gifProtoFuzzer.GifProto.header)
}

// required .gifProtoFuzzer.LogicalScreenDescriptor lsd = 2;
inline bool GifProto::_internal_has_lsd() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.lsd_ != nullptr);
  return value;
}
inline bool GifProto::has_lsd() const {
  return _internal_has_lsd();
}
inline void GifProto::clear_lsd() {
  if (_impl_.lsd_ != nullptr) _impl_.lsd_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::gifProtoFuzzer::LogicalScreenDescriptor& GifProto::_internal_lsd() const {
  const ::gifProtoFuzzer::LogicalScreenDescriptor* p = _impl_.lsd_;
  return p != nullptr ? *p : reinterpret_cast<const ::gifProtoFuzzer::LogicalScreenDescriptor&>(
      ::gifProtoFuzzer::_LogicalScreenDescriptor_default_instance_);
}
inline const ::gifProtoFuzzer::LogicalScreenDescriptor& GifProto::lsd() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.GifProto.lsd)
  return _internal_lsd();
}
inline void GifProto::unsafe_arena_set_allocated_lsd(
    ::gifProtoFuzzer::LogicalScreenDescriptor* lsd) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lsd_);
  }
  _impl_.lsd_ = lsd;
  if (lsd) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.GifProto.lsd)
}
inline ::gifProtoFuzzer::LogicalScreenDescriptor* GifProto::release_lsd() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::gifProtoFuzzer::LogicalScreenDescriptor* temp = _impl_.lsd_;
  _impl_.lsd_ = 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 ::gifProtoFuzzer::LogicalScreenDescriptor* GifProto::unsafe_arena_release_lsd() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.GifProto.lsd)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::gifProtoFuzzer::LogicalScreenDescriptor* temp = _impl_.lsd_;
  _impl_.lsd_ = nullptr;
  return temp;
}
inline ::gifProtoFuzzer::LogicalScreenDescriptor* GifProto::_internal_mutable_lsd() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.lsd_ == nullptr) {
    auto* p = CreateMaybeMessage<::gifProtoFuzzer::LogicalScreenDescriptor>(GetArenaForAllocation());
    _impl_.lsd_ = p;
  }
  return _impl_.lsd_;
}
inline ::gifProtoFuzzer::LogicalScreenDescriptor* GifProto::mutable_lsd() {
  ::gifProtoFuzzer::LogicalScreenDescriptor* _msg = _internal_mutable_lsd();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.GifProto.lsd)
  return _msg;
}
inline void GifProto::set_allocated_lsd(::gifProtoFuzzer::LogicalScreenDescriptor* lsd) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.lsd_;
  }
  if (lsd) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lsd);
    if (message_arena != submessage_arena) {
      lsd = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lsd, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.lsd_ = lsd;
  // @@protoc_insertion_point(field_set_allocated:gifProtoFuzzer.GifProto.lsd)
}

// required .gifProtoFuzzer.GlobalColorTable gct = 3;
inline bool GifProto::_internal_has_gct() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.gct_ != nullptr);
  return value;
}
inline bool GifProto::has_gct() const {
  return _internal_has_gct();
}
inline void GifProto::clear_gct() {
  if (_impl_.gct_ != nullptr) _impl_.gct_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::gifProtoFuzzer::GlobalColorTable& GifProto::_internal_gct() const {
  const ::gifProtoFuzzer::GlobalColorTable* p = _impl_.gct_;
  return p != nullptr ? *p : reinterpret_cast<const ::gifProtoFuzzer::GlobalColorTable&>(
      ::gifProtoFuzzer::_GlobalColorTable_default_instance_);
}
inline const ::gifProtoFuzzer::GlobalColorTable& GifProto::gct() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.GifProto.gct)
  return _internal_gct();
}
inline void GifProto::unsafe_arena_set_allocated_gct(
    ::gifProtoFuzzer::GlobalColorTable* gct) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.gct_);
  }
  _impl_.gct_ = gct;
  if (gct) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.GifProto.gct)
}
inline ::gifProtoFuzzer::GlobalColorTable* GifProto::release_gct() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::gifProtoFuzzer::GlobalColorTable* temp = _impl_.gct_;
  _impl_.gct_ = 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 ::gifProtoFuzzer::GlobalColorTable* GifProto::unsafe_arena_release_gct() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.GifProto.gct)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::gifProtoFuzzer::GlobalColorTable* temp = _impl_.gct_;
  _impl_.gct_ = nullptr;
  return temp;
}
inline ::gifProtoFuzzer::GlobalColorTable* GifProto::_internal_mutable_gct() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.gct_ == nullptr) {
    auto* p = CreateMaybeMessage<::gifProtoFuzzer::GlobalColorTable>(GetArenaForAllocation());
    _impl_.gct_ = p;
  }
  return _impl_.gct_;
}
inline ::gifProtoFuzzer::GlobalColorTable* GifProto::mutable_gct() {
  ::gifProtoFuzzer::GlobalColorTable* _msg = _internal_mutable_gct();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.GifProto.gct)
  return _msg;
}
inline void GifProto::set_allocated_gct(::gifProtoFuzzer::GlobalColorTable* gct) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.gct_;
  }
  if (gct) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(gct);
    if (message_arena != submessage_arena) {
      gct = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, gct, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.gct_ = gct;
  // @@protoc_insertion_point(field_set_allocated:gifProtoFuzzer.GifProto.gct)
}

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

// required .gifProtoFuzzer.Trailer trailer = 5;
inline bool GifProto::_internal_has_trailer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.trailer_ != nullptr);
  return value;
}
inline bool GifProto::has_trailer() const {
  return _internal_has_trailer();
}
inline void GifProto::clear_trailer() {
  if (_impl_.trailer_ != nullptr) _impl_.trailer_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::gifProtoFuzzer::Trailer& GifProto::_internal_trailer() const {
  const ::gifProtoFuzzer::Trailer* p = _impl_.trailer_;
  return p != nullptr ? *p : reinterpret_cast<const ::gifProtoFuzzer::Trailer&>(
      ::gifProtoFuzzer::_Trailer_default_instance_);
}
inline const ::gifProtoFuzzer::Trailer& GifProto::trailer() const {
  // @@protoc_insertion_point(field_get:gifProtoFuzzer.GifProto.trailer)
  return _internal_trailer();
}
inline void GifProto::unsafe_arena_set_allocated_trailer(
    ::gifProtoFuzzer::Trailer* trailer) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.trailer_);
  }
  _impl_.trailer_ = trailer;
  if (trailer) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gifProtoFuzzer.GifProto.trailer)
}
inline ::gifProtoFuzzer::Trailer* GifProto::release_trailer() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::gifProtoFuzzer::Trailer* temp = _impl_.trailer_;
  _impl_.trailer_ = 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 ::gifProtoFuzzer::Trailer* GifProto::unsafe_arena_release_trailer() {
  // @@protoc_insertion_point(field_release:gifProtoFuzzer.GifProto.trailer)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::gifProtoFuzzer::Trailer* temp = _impl_.trailer_;
  _impl_.trailer_ = nullptr;
  return temp;
}
inline ::gifProtoFuzzer::Trailer* GifProto::_internal_mutable_trailer() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.trailer_ == nullptr) {
    auto* p = CreateMaybeMessage<::gifProtoFuzzer::Trailer>(GetArenaForAllocation());
    _impl_.trailer_ = p;
  }
  return _impl_.trailer_;
}
inline ::gifProtoFuzzer::Trailer* GifProto::mutable_trailer() {
  ::gifProtoFuzzer::Trailer* _msg = _internal_mutable_trailer();
  // @@protoc_insertion_point(field_mutable:gifProtoFuzzer.GifProto.trailer)
  return _msg;
}
inline void GifProto::set_allocated_trailer(::gifProtoFuzzer::Trailer* trailer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.trailer_;
  }
  if (trailer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(trailer);
    if (message_arena != submessage_arena) {
      trailer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, trailer, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.trailer_ = trailer;
  // @@protoc_insertion_point(field_set_allocated:gifProtoFuzzer.GifProto.trailer)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace gifProtoFuzzer

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::gifProtoFuzzer::Header_Version> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::gifProtoFuzzer::Header_Version>() {
  return ::gifProtoFuzzer::Header_Version_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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

Coverage Report

Created: 2023-03-26 07:33