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

#ifndef lib_2fimagereader_2fimagereader_2eproto_2epb_2eh
#define lib_2fimagereader_2fimagereader_2eproto_2epb_2eh

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

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

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

#define PROTOBUF_INTERNAL_EXPORT_lib_2fimagereader_2fimagereader_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_lib_2fimagereader_2fimagereader_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_lib_2fimagereader_2fimagereader_2eproto;
}  // extern "C"
class D64InputProto;
struct D64InputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern D64InputProtoGlobalsTypeInternal D64InputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull D64InputProto_class_data_;
#else
extern const D64InputProtoGlobalsTypeInternal D64InputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class D88InputProto;
struct D88InputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern D88InputProtoGlobalsTypeInternal D88InputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull D88InputProto_class_data_;
#else
extern const D88InputProtoGlobalsTypeInternal D88InputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class DimInputProto;
struct DimInputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DimInputProtoGlobalsTypeInternal DimInputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull DimInputProto_class_data_;
#else
extern const DimInputProtoGlobalsTypeInternal DimInputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class DiskCopyInputProto;
struct DiskCopyInputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DiskCopyInputProtoGlobalsTypeInternal DiskCopyInputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull DiskCopyInputProto_class_data_;
#else
extern const DiskCopyInputProtoGlobalsTypeInternal DiskCopyInputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class FdiInputProto;
struct FdiInputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern FdiInputProtoGlobalsTypeInternal FdiInputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull FdiInputProto_class_data_;
#else
extern const FdiInputProtoGlobalsTypeInternal FdiInputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ImageReaderProto;
struct ImageReaderProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ImageReaderProtoGlobalsTypeInternal ImageReaderProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull ImageReaderProto_class_data_;
#else
extern const ImageReaderProtoGlobalsTypeInternal ImageReaderProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ImdInputProto;
struct ImdInputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ImdInputProtoGlobalsTypeInternal ImdInputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull ImdInputProto_class_data_;
#else
extern const ImdInputProtoGlobalsTypeInternal ImdInputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ImgInputOutputProto;
struct ImgInputOutputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ImgInputOutputProtoGlobalsTypeInternal ImgInputOutputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull ImgInputOutputProto_class_data_;
#else
extern const ImgInputOutputProtoGlobalsTypeInternal ImgInputOutputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Jv3InputProto;
struct Jv3InputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern Jv3InputProtoGlobalsTypeInternal Jv3InputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull Jv3InputProto_class_data_;
#else
extern const Jv3InputProtoGlobalsTypeInternal Jv3InputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class NfdInputProto;
struct NfdInputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern NfdInputProtoGlobalsTypeInternal NfdInputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull NfdInputProto_class_data_;
#else
extern const NfdInputProtoGlobalsTypeInternal NfdInputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class NsiInputProto;
struct NsiInputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern NsiInputProtoGlobalsTypeInternal NsiInputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull NsiInputProto_class_data_;
#else
extern const NsiInputProtoGlobalsTypeInternal NsiInputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Td0InputProto;
struct Td0InputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern Td0InputProtoGlobalsTypeInternal Td0InputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull Td0InputProto_class_data_;
#else
extern const Td0InputProtoGlobalsTypeInternal Td0InputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google


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


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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Td0InputProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:Td0InputProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline Td0InputProto() : Td0InputProto(nullptr) {}

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

  template <typename = void>
  explicit constexpr Td0InputProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

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

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

  [[nodiscard]] Td0InputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<Td0InputProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const Td0InputProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const Td0InputProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "Td0InputProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:Td0InputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2fimagereader_2fimagereader_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED NsiInputProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:NsiInputProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline NsiInputProto() : NsiInputProto(nullptr) {}

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

  template <typename = void>
  explicit constexpr NsiInputProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

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

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

  [[nodiscard]] NsiInputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<NsiInputProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const NsiInputProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const NsiInputProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "NsiInputProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:NsiInputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2fimagereader_2fimagereader_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED NfdInputProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:NfdInputProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline NfdInputProto() : NfdInputProto(nullptr) {}

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

  template <typename = void>
  explicit constexpr NfdInputProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const NfdInputProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<NfdInputProto>(&NfdInputProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 10;
  friend void swap(NfdInputProto& a, NfdInputProto& b) { a.Swap(&b); }
  inline void Swap(NfdInputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NfdInputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] NfdInputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<NfdInputProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const NfdInputProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const NfdInputProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "NfdInputProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:NfdInputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2fimagereader_2fimagereader_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Jv3InputProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:Jv3InputProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline Jv3InputProto() : Jv3InputProto(nullptr) {}

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

  template <typename = void>
  explicit constexpr Jv3InputProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

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

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

  [[nodiscard]] Jv3InputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<Jv3InputProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const Jv3InputProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const Jv3InputProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "Jv3InputProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:Jv3InputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2fimagereader_2fimagereader_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ImgInputOutputProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:ImgInputOutputProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline ImgInputOutputProto() : ImgInputOutputProto(nullptr) {}
  ~ImgInputOutputProto() PROTOBUF_FINAL;

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

  template <typename = void>
  explicit constexpr ImgInputOutputProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

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

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

  [[nodiscard]] ImgInputOutputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<ImgInputOutputProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const ImgInputOutputProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const ImgInputOutputProto& from) { ImgInputOutputProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ImgInputOutputProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "ImgInputOutputProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kFilesystemSectorOrderFieldNumber = 1,
  };
  // optional bool filesystem_sector_order = 1 [default = false, json_name = "filesystemSectorOrder", (.help) = "read/write sector image in filesystem order"];
  [[nodiscard]] bool has_filesystem_sector_order() const;
  void clear_filesystem_sector_order() ;
  [[nodiscard]] bool filesystem_sector_order() const;
  void set_filesystem_sector_order(bool value);

  private:
  bool _internal_filesystem_sector_order() const;
  void _internal_set_filesystem_sector_order(bool value);

  public:
  // @@protoc_insertion_point(class_scope:ImgInputOutputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ImdInputProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:ImdInputProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline ImdInputProto() : ImdInputProto(nullptr) {}

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

  template <typename = void>
  explicit constexpr ImdInputProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ImdInputProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ImdInputProto>(&ImdInputProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(ImdInputProto& a, ImdInputProto& b) { a.Swap(&b); }
  inline void Swap(ImdInputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ImdInputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ImdInputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<ImdInputProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const ImdInputProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const ImdInputProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "ImdInputProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:ImdInputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2fimagereader_2fimagereader_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED FdiInputProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:FdiInputProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline FdiInputProto() : FdiInputProto(nullptr) {}

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

  template <typename = void>
  explicit constexpr FdiInputProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

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

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

  [[nodiscard]] FdiInputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<FdiInputProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const FdiInputProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const FdiInputProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "FdiInputProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:FdiInputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2fimagereader_2fimagereader_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED DiskCopyInputProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:DiskCopyInputProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline DiskCopyInputProto() : DiskCopyInputProto(nullptr) {}

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

  template <typename = void>
  explicit constexpr DiskCopyInputProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

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

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

  [[nodiscard]] DiskCopyInputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<DiskCopyInputProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const DiskCopyInputProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const DiskCopyInputProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "DiskCopyInputProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:DiskCopyInputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2fimagereader_2fimagereader_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED DimInputProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:DimInputProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline DimInputProto() : DimInputProto(nullptr) {}

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

  template <typename = void>
  explicit constexpr DimInputProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const DimInputProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<DimInputProto>(&DimInputProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(DimInputProto& a, DimInputProto& b) { a.Swap(&b); }
  inline void Swap(DimInputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DimInputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] DimInputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<DimInputProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const DimInputProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const DimInputProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "DimInputProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:DimInputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2fimagereader_2fimagereader_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED D88InputProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:D88InputProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline D88InputProto() : D88InputProto(nullptr) {}

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

  template <typename = void>
  explicit constexpr D88InputProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

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

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

  [[nodiscard]] D88InputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<D88InputProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const D88InputProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const D88InputProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "D88InputProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:D88InputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2fimagereader_2fimagereader_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED D64InputProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:D64InputProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline D64InputProto() : D64InputProto(nullptr) {}

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

  template <typename = void>
  explicit constexpr D64InputProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

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

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

  [[nodiscard]] D64InputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<D64InputProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const D64InputProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const D64InputProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "D64InputProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:D64InputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2fimagereader_2fimagereader_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ImageReaderProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:ImageReaderProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline ImageReaderProto() : ImageReaderProto(nullptr) {}
  ~ImageReaderProto() PROTOBUF_FINAL;

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

  template <typename = void>
  explicit constexpr ImageReaderProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

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

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

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ImageReaderProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ImageReaderProto>(&ImageReaderProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 11;
  friend void swap(ImageReaderProto& a, ImageReaderProto& b) { a.Swap(&b); }
  inline void Swap(ImageReaderProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ImageReaderProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ImageReaderProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<ImageReaderProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const ImageReaderProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const ImageReaderProto& from) { ImageReaderProto::MergeImpl(*this, from); }

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

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

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

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ImageReaderProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "ImageReaderProto"; }

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

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kFilenameFieldNumber = 1,
    kImgFieldNumber = 2,
    kDiskcopyFieldNumber = 3,
    kImdFieldNumber = 4,
    kJv3FieldNumber = 5,
    kD64FieldNumber = 6,
    kNsiFieldNumber = 7,
    kTd0FieldNumber = 8,
    kDimFieldNumber = 9,
    kFdiFieldNumber = 10,
    kD88FieldNumber = 11,
    kNfdFieldNumber = 12,
    kTypeFieldNumber = 13,
  };
  // optional string filename = 1 [json_name = "filename", (.help) = "filename of input sector image"];
  [[nodiscard]] bool has_filename() const;
  void clear_filename() ;
  [[nodiscard]] const ::std::string& filename() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_filename(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_filename();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_filename();
  void set_allocated_filename(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_filename() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_filename();

  public:
  // optional .ImgInputOutputProto img = 2 [json_name = "img"];
  [[nodiscard]] bool has_img() const;
  void clear_img() ;
  [[nodiscard]] const ::ImgInputOutputProto& img() const;
  [[nodiscard]] ::ImgInputOutputProto* PROTOBUF_NULLABLE release_img();
  ::ImgInputOutputProto* PROTOBUF_NONNULL mutable_img();
  void set_allocated_img(::ImgInputOutputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_img(::ImgInputOutputProto* PROTOBUF_NULLABLE value);
  ::ImgInputOutputProto* PROTOBUF_NULLABLE unsafe_arena_release_img();

  private:
  const ::ImgInputOutputProto& _internal_img() const;
  ::ImgInputOutputProto* PROTOBUF_NONNULL _internal_mutable_img();

  public:
  // optional .DiskCopyInputProto diskcopy = 3 [json_name = "diskcopy"];
  [[nodiscard]] bool has_diskcopy() const;
  void clear_diskcopy() ;
  [[nodiscard]] const ::DiskCopyInputProto& diskcopy() const;
  [[nodiscard]] ::DiskCopyInputProto* PROTOBUF_NULLABLE release_diskcopy();
  ::DiskCopyInputProto* PROTOBUF_NONNULL mutable_diskcopy();
  void set_allocated_diskcopy(::DiskCopyInputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_diskcopy(::DiskCopyInputProto* PROTOBUF_NULLABLE value);
  ::DiskCopyInputProto* PROTOBUF_NULLABLE unsafe_arena_release_diskcopy();

  private:
  const ::DiskCopyInputProto& _internal_diskcopy() const;
  ::DiskCopyInputProto* PROTOBUF_NONNULL _internal_mutable_diskcopy();

  public:
  // optional .ImdInputProto imd = 4 [json_name = "imd"];
  [[nodiscard]] bool has_imd() const;
  void clear_imd() ;
  [[nodiscard]] const ::ImdInputProto& imd() const;
  [[nodiscard]] ::ImdInputProto* PROTOBUF_NULLABLE release_imd();
  ::ImdInputProto* PROTOBUF_NONNULL mutable_imd();
  void set_allocated_imd(::ImdInputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_imd(::ImdInputProto* PROTOBUF_NULLABLE value);
  ::ImdInputProto* PROTOBUF_NULLABLE unsafe_arena_release_imd();

  private:
  const ::ImdInputProto& _internal_imd() const;
  ::ImdInputProto* PROTOBUF_NONNULL _internal_mutable_imd();

  public:
  // optional .Jv3InputProto jv3 = 5 [json_name = "jv3"];
  [[nodiscard]] bool has_jv3() const;
  void clear_jv3() ;
  [[nodiscard]] const ::Jv3InputProto& jv3() const;
  [[nodiscard]] ::Jv3InputProto* PROTOBUF_NULLABLE release_jv3();
  ::Jv3InputProto* PROTOBUF_NONNULL mutable_jv3();
  void set_allocated_jv3(::Jv3InputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_jv3(::Jv3InputProto* PROTOBUF_NULLABLE value);
  ::Jv3InputProto* PROTOBUF_NULLABLE unsafe_arena_release_jv3();

  private:
  const ::Jv3InputProto& _internal_jv3() const;
  ::Jv3InputProto* PROTOBUF_NONNULL _internal_mutable_jv3();

  public:
  // optional .D64InputProto d64 = 6 [json_name = "d64"];
  [[nodiscard]] bool has_d64() const;
  void clear_d64() ;
  [[nodiscard]] const ::D64InputProto& d64() const;
  [[nodiscard]] ::D64InputProto* PROTOBUF_NULLABLE release_d64();
  ::D64InputProto* PROTOBUF_NONNULL mutable_d64();
  void set_allocated_d64(::D64InputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_d64(::D64InputProto* PROTOBUF_NULLABLE value);
  ::D64InputProto* PROTOBUF_NULLABLE unsafe_arena_release_d64();

  private:
  const ::D64InputProto& _internal_d64() const;
  ::D64InputProto* PROTOBUF_NONNULL _internal_mutable_d64();

  public:
  // optional .NsiInputProto nsi = 7 [json_name = "nsi"];
  [[nodiscard]] bool has_nsi() const;
  void clear_nsi() ;
  [[nodiscard]] const ::NsiInputProto& nsi() const;
  [[nodiscard]] ::NsiInputProto* PROTOBUF_NULLABLE release_nsi();
  ::NsiInputProto* PROTOBUF_NONNULL mutable_nsi();
  void set_allocated_nsi(::NsiInputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_nsi(::NsiInputProto* PROTOBUF_NULLABLE value);
  ::NsiInputProto* PROTOBUF_NULLABLE unsafe_arena_release_nsi();

  private:
  const ::NsiInputProto& _internal_nsi() const;
  ::NsiInputProto* PROTOBUF_NONNULL _internal_mutable_nsi();

  public:
  // optional .Td0InputProto td0 = 8 [json_name = "td0"];
  [[nodiscard]] bool has_td0() const;
  void clear_td0() ;
  [[nodiscard]] const ::Td0InputProto& td0() const;
  [[nodiscard]] ::Td0InputProto* PROTOBUF_NULLABLE release_td0();
  ::Td0InputProto* PROTOBUF_NONNULL mutable_td0();
  void set_allocated_td0(::Td0InputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_td0(::Td0InputProto* PROTOBUF_NULLABLE value);
  ::Td0InputProto* PROTOBUF_NULLABLE unsafe_arena_release_td0();

  private:
  const ::Td0InputProto& _internal_td0() const;
  ::Td0InputProto* PROTOBUF_NONNULL _internal_mutable_td0();

  public:
  // optional .DimInputProto dim = 9 [json_name = "dim"];
  [[nodiscard]] bool has_dim() const;
  void clear_dim() ;
  [[nodiscard]] const ::DimInputProto& dim() const;
  [[nodiscard]] ::DimInputProto* PROTOBUF_NULLABLE release_dim();
  ::DimInputProto* PROTOBUF_NONNULL mutable_dim();
  void set_allocated_dim(::DimInputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_dim(::DimInputProto* PROTOBUF_NULLABLE value);
  ::DimInputProto* PROTOBUF_NULLABLE unsafe_arena_release_dim();

  private:
  const ::DimInputProto& _internal_dim() const;
  ::DimInputProto* PROTOBUF_NONNULL _internal_mutable_dim();

  public:
  // optional .FdiInputProto fdi = 10 [json_name = "fdi"];
  [[nodiscard]] bool has_fdi() const;
  void clear_fdi() ;
  [[nodiscard]] const ::FdiInputProto& fdi() const;
  [[nodiscard]] ::FdiInputProto* PROTOBUF_NULLABLE release_fdi();
  ::FdiInputProto* PROTOBUF_NONNULL mutable_fdi();
  void set_allocated_fdi(::FdiInputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_fdi(::FdiInputProto* PROTOBUF_NULLABLE value);
  ::FdiInputProto* PROTOBUF_NULLABLE unsafe_arena_release_fdi();

  private:
  const ::FdiInputProto& _internal_fdi() const;
  ::FdiInputProto* PROTOBUF_NONNULL _internal_mutable_fdi();

  public:
  // optional .D88InputProto d88 = 11 [json_name = "d88"];
  [[nodiscard]] bool has_d88() const;
  void clear_d88() ;
  [[nodiscard]] const ::D88InputProto& d88() const;
  [[nodiscard]] ::D88InputProto* PROTOBUF_NULLABLE release_d88();
  ::D88InputProto* PROTOBUF_NONNULL mutable_d88();
  void set_allocated_d88(::D88InputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_d88(::D88InputProto* PROTOBUF_NULLABLE value);
  ::D88InputProto* PROTOBUF_NULLABLE unsafe_arena_release_d88();

  private:
  const ::D88InputProto& _internal_d88() const;
  ::D88InputProto* PROTOBUF_NONNULL _internal_mutable_d88();

  public:
  // optional .NfdInputProto nfd = 12 [json_name = "nfd"];
  [[nodiscard]] bool has_nfd() const;
  void clear_nfd() ;
  [[nodiscard]] const ::NfdInputProto& nfd() const;
  [[nodiscard]] ::NfdInputProto* PROTOBUF_NULLABLE release_nfd();
  ::NfdInputProto* PROTOBUF_NONNULL mutable_nfd();
  void set_allocated_nfd(::NfdInputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_nfd(::NfdInputProto* PROTOBUF_NULLABLE value);
  ::NfdInputProto* PROTOBUF_NULLABLE unsafe_arena_release_nfd();

  private:
  const ::NfdInputProto& _internal_nfd() const;
  ::NfdInputProto* PROTOBUF_NONNULL _internal_mutable_nfd();

  public:
  // optional .ImageReaderWriterType type = 13 [default = IMAGETYPE_NOT_SET, json_name = "type", (.help) = "input image type"];
  [[nodiscard]] bool has_type() const;
  void clear_type() ;
  [[nodiscard]] ::ImageReaderWriterType type() const;
  void set_type(::ImageReaderWriterType value);

  private:
  ::ImageReaderWriterType _internal_type() const;
  void _internal_set_type(::ImageReaderWriterType value);

  public:
  // @@protoc_insertion_point(class_scope:ImageReaderProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<4, 13,
                          12, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ImageReaderProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr filename_;
    ::ImgInputOutputProto* PROTOBUF_NULLABLE img_;
    ::DiskCopyInputProto* PROTOBUF_NULLABLE diskcopy_;
    ::ImdInputProto* PROTOBUF_NULLABLE imd_;
    ::Jv3InputProto* PROTOBUF_NULLABLE jv3_;
    ::D64InputProto* PROTOBUF_NULLABLE d64_;
    ::NsiInputProto* PROTOBUF_NULLABLE nsi_;
    ::Td0InputProto* PROTOBUF_NULLABLE td0_;
    ::DimInputProto* PROTOBUF_NULLABLE dim_;
    ::FdiInputProto* PROTOBUF_NULLABLE fdi_;
    ::D88InputProto* PROTOBUF_NULLABLE d88_;
    ::NfdInputProto* PROTOBUF_NULLABLE nfd_;
    int type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fimagereader_2fimagereader_2eproto;
};

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




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


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

// ImgInputOutputProto

// optional bool filesystem_sector_order = 1 [default = false, json_name = "filesystemSectorOrder", (.help) = "read/write sector image in filesystem order"];
inline bool ImgInputOutputProto::has_filesystem_sector_order() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void ImgInputOutputProto::clear_filesystem_sector_order() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filesystem_sector_order_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline bool ImgInputOutputProto::filesystem_sector_order() const {
  // @@protoc_insertion_point(field_get:ImgInputOutputProto.filesystem_sector_order)
  return _internal_filesystem_sector_order();
}
inline void ImgInputOutputProto::set_filesystem_sector_order(bool value) {
  _internal_set_filesystem_sector_order(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:ImgInputOutputProto.filesystem_sector_order)
}
inline bool ImgInputOutputProto::_internal_filesystem_sector_order() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filesystem_sector_order_;
}
inline void ImgInputOutputProto::_internal_set_filesystem_sector_order(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filesystem_sector_order_ = value;
}

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

// DiskCopyInputProto

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

// ImdInputProto

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

// Jv3InputProto

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

// D64InputProto

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

// NsiInputProto

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

// Td0InputProto

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

// DimInputProto

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

// FdiInputProto

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

// D88InputProto

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

// NfdInputProto

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

// ImageReaderProto

// optional string filename = 1 [json_name = "filename", (.help) = "filename of input sector image"];
inline bool ImageReaderProto::has_filename() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void ImageReaderProto::clear_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& ImageReaderProto::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.filename)
  return _internal_filename();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ImageReaderProto::set_filename(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.filename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:ImageReaderProto.filename)
}
inline ::std::string* PROTOBUF_NONNULL ImageReaderProto::mutable_filename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.filename)
  return _s;
}
inline const ::std::string& ImageReaderProto::_internal_filename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filename_.Get();
}
inline void ImageReaderProto::_internal_set_filename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.filename_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ImageReaderProto::release_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.filename)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.filename_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.filename_.Set("", GetArena());
  }
  return released;
}
inline void ImageReaderProto::set_allocated_filename(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.filename_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.filename_.IsDefault()) {
    _impl_.filename_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.filename)
}

// optional .ImageReaderWriterType type = 13 [default = IMAGETYPE_NOT_SET, json_name = "type", (.help) = "input image type"];
inline bool ImageReaderProto::has_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  return value;
}
inline void ImageReaderProto::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline ::ImageReaderWriterType ImageReaderProto::type() const {
  // @@protoc_insertion_point(field_get:ImageReaderProto.type)
  return _internal_type();
}
inline void ImageReaderProto::set_type(::ImageReaderWriterType value) {
  _internal_set_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  // @@protoc_insertion_point(field_set:ImageReaderProto.type)
}
inline ::ImageReaderWriterType ImageReaderProto::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::ImageReaderWriterType>(_impl_.type_);
}
inline void ImageReaderProto::_internal_set_type(::ImageReaderWriterType value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::ImageReaderWriterType_internal_data_));
                                          _impl_.type_ = value;
}

// optional .ImgInputOutputProto img = 2 [json_name = "img"];
inline bool ImageReaderProto::has_img() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.img_ != nullptr);
  return value;
}
inline void ImageReaderProto::clear_img() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.img_ != nullptr) _impl_.img_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::ImgInputOutputProto& ImageReaderProto::_internal_img() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::ImgInputOutputProto* p = _impl_.img_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::ImgInputOutputProto>(&::ImgInputOutputProto_globals_);
}
inline const ::ImgInputOutputProto& ImageReaderProto::img() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.img)
  return _internal_img();
}
inline void ImageReaderProto::unsafe_arena_set_allocated_img(
    ::ImgInputOutputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.img_);
  }
  _impl_.img_ = reinterpret_cast<::ImgInputOutputProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ImageReaderProto.img)
}
inline ::ImgInputOutputProto* PROTOBUF_NULLABLE ImageReaderProto::release_img() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::ImgInputOutputProto* released = _impl_.img_;
  _impl_.img_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::ImgInputOutputProto* PROTOBUF_NULLABLE ImageReaderProto::unsafe_arena_release_img() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.img)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::ImgInputOutputProto* temp = _impl_.img_;
  _impl_.img_ = nullptr;
  return temp;
}
inline ::ImgInputOutputProto* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_img() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.img_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::ImgInputOutputProto>(GetArena());
    _impl_.img_ = reinterpret_cast<::ImgInputOutputProto*>(p);
  }
  return _impl_.img_;
}
inline ::ImgInputOutputProto* PROTOBUF_NONNULL ImageReaderProto::mutable_img()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::ImgInputOutputProto* _msg = _internal_mutable_img();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.img)
  return _msg;
}
inline void ImageReaderProto::set_allocated_img(::ImgInputOutputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.img_);
  }

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

  _impl_.img_ = reinterpret_cast<::ImgInputOutputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.img)
}

// optional .DiskCopyInputProto diskcopy = 3 [json_name = "diskcopy"];
inline bool ImageReaderProto::has_diskcopy() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.diskcopy_ != nullptr);
  return value;
}
inline void ImageReaderProto::clear_diskcopy() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.diskcopy_ != nullptr) _impl_.diskcopy_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::DiskCopyInputProto& ImageReaderProto::_internal_diskcopy() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::DiskCopyInputProto* p = _impl_.diskcopy_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::DiskCopyInputProto>(&::DiskCopyInputProto_globals_);
}
inline const ::DiskCopyInputProto& ImageReaderProto::diskcopy() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.diskcopy)
  return _internal_diskcopy();
}
inline void ImageReaderProto::unsafe_arena_set_allocated_diskcopy(
    ::DiskCopyInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.diskcopy_);
  }
  _impl_.diskcopy_ = reinterpret_cast<::DiskCopyInputProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ImageReaderProto.diskcopy)
}
inline ::DiskCopyInputProto* PROTOBUF_NULLABLE ImageReaderProto::release_diskcopy() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::DiskCopyInputProto* released = _impl_.diskcopy_;
  _impl_.diskcopy_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::DiskCopyInputProto* PROTOBUF_NULLABLE ImageReaderProto::unsafe_arena_release_diskcopy() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.diskcopy)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::DiskCopyInputProto* temp = _impl_.diskcopy_;
  _impl_.diskcopy_ = nullptr;
  return temp;
}
inline ::DiskCopyInputProto* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_diskcopy() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.diskcopy_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::DiskCopyInputProto>(GetArena());
    _impl_.diskcopy_ = reinterpret_cast<::DiskCopyInputProto*>(p);
  }
  return _impl_.diskcopy_;
}
inline ::DiskCopyInputProto* PROTOBUF_NONNULL ImageReaderProto::mutable_diskcopy()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::DiskCopyInputProto* _msg = _internal_mutable_diskcopy();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.diskcopy)
  return _msg;
}
inline void ImageReaderProto::set_allocated_diskcopy(::DiskCopyInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.diskcopy_);
  }

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

  _impl_.diskcopy_ = reinterpret_cast<::DiskCopyInputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.diskcopy)
}

// optional .ImdInputProto imd = 4 [json_name = "imd"];
inline bool ImageReaderProto::has_imd() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.imd_ != nullptr);
  return value;
}
inline void ImageReaderProto::clear_imd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.imd_ != nullptr) _impl_.imd_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::ImdInputProto& ImageReaderProto::_internal_imd() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::ImdInputProto* p = _impl_.imd_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::ImdInputProto>(&::ImdInputProto_globals_);
}
inline const ::ImdInputProto& ImageReaderProto::imd() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.imd)
  return _internal_imd();
}
inline void ImageReaderProto::unsafe_arena_set_allocated_imd(
    ::ImdInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.imd_);
  }
  _impl_.imd_ = reinterpret_cast<::ImdInputProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ImageReaderProto.imd)
}
inline ::ImdInputProto* PROTOBUF_NULLABLE ImageReaderProto::release_imd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::ImdInputProto* released = _impl_.imd_;
  _impl_.imd_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::ImdInputProto* PROTOBUF_NULLABLE ImageReaderProto::unsafe_arena_release_imd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.imd)

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::ImdInputProto* temp = _impl_.imd_;
  _impl_.imd_ = nullptr;
  return temp;
}
inline ::ImdInputProto* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_imd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.imd_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::ImdInputProto>(GetArena());
    _impl_.imd_ = reinterpret_cast<::ImdInputProto*>(p);
  }
  return _impl_.imd_;
}
inline ::ImdInputProto* PROTOBUF_NONNULL ImageReaderProto::mutable_imd()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::ImdInputProto* _msg = _internal_mutable_imd();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.imd)
  return _msg;
}
inline void ImageReaderProto::set_allocated_imd(::ImdInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.imd_);
  }

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

  _impl_.imd_ = reinterpret_cast<::ImdInputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.imd)
}

// optional .Jv3InputProto jv3 = 5 [json_name = "jv3"];
inline bool ImageReaderProto::has_jv3() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.jv3_ != nullptr);
  return value;
}
inline void ImageReaderProto::clear_jv3() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.jv3_ != nullptr) _impl_.jv3_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::Jv3InputProto& ImageReaderProto::_internal_jv3() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::Jv3InputProto* p = _impl_.jv3_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::Jv3InputProto>(&::Jv3InputProto_globals_);
}
inline const ::Jv3InputProto& ImageReaderProto::jv3() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.jv3)
  return _internal_jv3();
}
inline void ImageReaderProto::unsafe_arena_set_allocated_jv3(
    ::Jv3InputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.jv3_);
  }
  _impl_.jv3_ = reinterpret_cast<::Jv3InputProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ImageReaderProto.jv3)
}
inline ::Jv3InputProto* PROTOBUF_NULLABLE ImageReaderProto::release_jv3() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::Jv3InputProto* released = _impl_.jv3_;
  _impl_.jv3_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::Jv3InputProto* PROTOBUF_NULLABLE ImageReaderProto::unsafe_arena_release_jv3() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.jv3)

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::Jv3InputProto* temp = _impl_.jv3_;
  _impl_.jv3_ = nullptr;
  return temp;
}
inline ::Jv3InputProto* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_jv3() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.jv3_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::Jv3InputProto>(GetArena());
    _impl_.jv3_ = reinterpret_cast<::Jv3InputProto*>(p);
  }
  return _impl_.jv3_;
}
inline ::Jv3InputProto* PROTOBUF_NONNULL ImageReaderProto::mutable_jv3()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::Jv3InputProto* _msg = _internal_mutable_jv3();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.jv3)
  return _msg;
}
inline void ImageReaderProto::set_allocated_jv3(::Jv3InputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.jv3_);
  }

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

  _impl_.jv3_ = reinterpret_cast<::Jv3InputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.jv3)
}

// optional .D64InputProto d64 = 6 [json_name = "d64"];
inline bool ImageReaderProto::has_d64() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  PROTOBUF_ASSUME(!value || _impl_.d64_ != nullptr);
  return value;
}
inline void ImageReaderProto::clear_d64() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.d64_ != nullptr) _impl_.d64_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::D64InputProto& ImageReaderProto::_internal_d64() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::D64InputProto* p = _impl_.d64_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::D64InputProto>(&::D64InputProto_globals_);
}
inline const ::D64InputProto& ImageReaderProto::d64() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.d64)
  return _internal_d64();
}
inline void ImageReaderProto::unsafe_arena_set_allocated_d64(
    ::D64InputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.d64_);
  }
  _impl_.d64_ = reinterpret_cast<::D64InputProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ImageReaderProto.d64)
}
inline ::D64InputProto* PROTOBUF_NULLABLE ImageReaderProto::release_d64() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::D64InputProto* released = _impl_.d64_;
  _impl_.d64_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::D64InputProto* PROTOBUF_NULLABLE ImageReaderProto::unsafe_arena_release_d64() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.d64)

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::D64InputProto* temp = _impl_.d64_;
  _impl_.d64_ = nullptr;
  return temp;
}
inline ::D64InputProto* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_d64() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.d64_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::D64InputProto>(GetArena());
    _impl_.d64_ = reinterpret_cast<::D64InputProto*>(p);
  }
  return _impl_.d64_;
}
inline ::D64InputProto* PROTOBUF_NONNULL ImageReaderProto::mutable_d64()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::D64InputProto* _msg = _internal_mutable_d64();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.d64)
  return _msg;
}
inline void ImageReaderProto::set_allocated_d64(::D64InputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.d64_);
  }

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

  _impl_.d64_ = reinterpret_cast<::D64InputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.d64)
}

// optional .NsiInputProto nsi = 7 [json_name = "nsi"];
inline bool ImageReaderProto::has_nsi() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  PROTOBUF_ASSUME(!value || _impl_.nsi_ != nullptr);
  return value;
}
inline void ImageReaderProto::clear_nsi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.nsi_ != nullptr) _impl_.nsi_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::NsiInputProto& ImageReaderProto::_internal_nsi() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::NsiInputProto* p = _impl_.nsi_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::NsiInputProto>(&::NsiInputProto_globals_);
}
inline const ::NsiInputProto& ImageReaderProto::nsi() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.nsi)
  return _internal_nsi();
}
inline void ImageReaderProto::unsafe_arena_set_allocated_nsi(
    ::NsiInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.nsi_);
  }
  _impl_.nsi_ = reinterpret_cast<::NsiInputProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ImageReaderProto.nsi)
}
inline ::NsiInputProto* PROTOBUF_NULLABLE ImageReaderProto::release_nsi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::NsiInputProto* released = _impl_.nsi_;
  _impl_.nsi_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::NsiInputProto* PROTOBUF_NULLABLE ImageReaderProto::unsafe_arena_release_nsi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.nsi)

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::NsiInputProto* temp = _impl_.nsi_;
  _impl_.nsi_ = nullptr;
  return temp;
}
inline ::NsiInputProto* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_nsi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.nsi_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::NsiInputProto>(GetArena());
    _impl_.nsi_ = reinterpret_cast<::NsiInputProto*>(p);
  }
  return _impl_.nsi_;
}
inline ::NsiInputProto* PROTOBUF_NONNULL ImageReaderProto::mutable_nsi()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::NsiInputProto* _msg = _internal_mutable_nsi();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.nsi)
  return _msg;
}
inline void ImageReaderProto::set_allocated_nsi(::NsiInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.nsi_);
  }

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

  _impl_.nsi_ = reinterpret_cast<::NsiInputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.nsi)
}

// optional .Td0InputProto td0 = 8 [json_name = "td0"];
inline bool ImageReaderProto::has_td0() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  PROTOBUF_ASSUME(!value || _impl_.td0_ != nullptr);
  return value;
}
inline void ImageReaderProto::clear_td0() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.td0_ != nullptr) _impl_.td0_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::Td0InputProto& ImageReaderProto::_internal_td0() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::Td0InputProto* p = _impl_.td0_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::Td0InputProto>(&::Td0InputProto_globals_);
}
inline const ::Td0InputProto& ImageReaderProto::td0() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.td0)
  return _internal_td0();
}
inline void ImageReaderProto::unsafe_arena_set_allocated_td0(
    ::Td0InputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.td0_);
  }
  _impl_.td0_ = reinterpret_cast<::Td0InputProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ImageReaderProto.td0)
}
inline ::Td0InputProto* PROTOBUF_NULLABLE ImageReaderProto::release_td0() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::Td0InputProto* released = _impl_.td0_;
  _impl_.td0_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::Td0InputProto* PROTOBUF_NULLABLE ImageReaderProto::unsafe_arena_release_td0() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.td0)

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::Td0InputProto* temp = _impl_.td0_;
  _impl_.td0_ = nullptr;
  return temp;
}
inline ::Td0InputProto* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_td0() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.td0_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::Td0InputProto>(GetArena());
    _impl_.td0_ = reinterpret_cast<::Td0InputProto*>(p);
  }
  return _impl_.td0_;
}
inline ::Td0InputProto* PROTOBUF_NONNULL ImageReaderProto::mutable_td0()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::Td0InputProto* _msg = _internal_mutable_td0();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.td0)
  return _msg;
}
inline void ImageReaderProto::set_allocated_td0(::Td0InputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.td0_);
  }

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

  _impl_.td0_ = reinterpret_cast<::Td0InputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.td0)
}

// optional .DimInputProto dim = 9 [json_name = "dim"];
inline bool ImageReaderProto::has_dim() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.dim_ != nullptr);
  return value;
}
inline void ImageReaderProto::clear_dim() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.dim_ != nullptr) _impl_.dim_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline const ::DimInputProto& ImageReaderProto::_internal_dim() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::DimInputProto* p = _impl_.dim_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::DimInputProto>(&::DimInputProto_globals_);
}
inline const ::DimInputProto& ImageReaderProto::dim() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.dim)
  return _internal_dim();
}
inline void ImageReaderProto::unsafe_arena_set_allocated_dim(
    ::DimInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.dim_);
  }
  _impl_.dim_ = reinterpret_cast<::DimInputProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ImageReaderProto.dim)
}
inline ::DimInputProto* PROTOBUF_NULLABLE ImageReaderProto::release_dim() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::DimInputProto* released = _impl_.dim_;
  _impl_.dim_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::DimInputProto* PROTOBUF_NULLABLE ImageReaderProto::unsafe_arena_release_dim() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.dim)

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::DimInputProto* temp = _impl_.dim_;
  _impl_.dim_ = nullptr;
  return temp;
}
inline ::DimInputProto* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_dim() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.dim_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::DimInputProto>(GetArena());
    _impl_.dim_ = reinterpret_cast<::DimInputProto*>(p);
  }
  return _impl_.dim_;
}
inline ::DimInputProto* PROTOBUF_NONNULL ImageReaderProto::mutable_dim()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::DimInputProto* _msg = _internal_mutable_dim();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.dim)
  return _msg;
}
inline void ImageReaderProto::set_allocated_dim(::DimInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.dim_);
  }

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

  _impl_.dim_ = reinterpret_cast<::DimInputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.dim)
}

// optional .FdiInputProto fdi = 10 [json_name = "fdi"];
inline bool ImageReaderProto::has_fdi() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  PROTOBUF_ASSUME(!value || _impl_.fdi_ != nullptr);
  return value;
}
inline void ImageReaderProto::clear_fdi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.fdi_ != nullptr) _impl_.fdi_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline const ::FdiInputProto& ImageReaderProto::_internal_fdi() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::FdiInputProto* p = _impl_.fdi_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::FdiInputProto>(&::FdiInputProto_globals_);
}
inline const ::FdiInputProto& ImageReaderProto::fdi() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.fdi)
  return _internal_fdi();
}
inline void ImageReaderProto::unsafe_arena_set_allocated_fdi(
    ::FdiInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.fdi_);
  }
  _impl_.fdi_ = reinterpret_cast<::FdiInputProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ImageReaderProto.fdi)
}
inline ::FdiInputProto* PROTOBUF_NULLABLE ImageReaderProto::release_fdi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::FdiInputProto* released = _impl_.fdi_;
  _impl_.fdi_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::FdiInputProto* PROTOBUF_NULLABLE ImageReaderProto::unsafe_arena_release_fdi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.fdi)

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::FdiInputProto* temp = _impl_.fdi_;
  _impl_.fdi_ = nullptr;
  return temp;
}
inline ::FdiInputProto* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_fdi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.fdi_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::FdiInputProto>(GetArena());
    _impl_.fdi_ = reinterpret_cast<::FdiInputProto*>(p);
  }
  return _impl_.fdi_;
}
inline ::FdiInputProto* PROTOBUF_NONNULL ImageReaderProto::mutable_fdi()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::FdiInputProto* _msg = _internal_mutable_fdi();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.fdi)
  return _msg;
}
inline void ImageReaderProto::set_allocated_fdi(::FdiInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.fdi_);
  }

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

  _impl_.fdi_ = reinterpret_cast<::FdiInputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.fdi)
}

// optional .D88InputProto d88 = 11 [json_name = "d88"];
inline bool ImageReaderProto::has_d88() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  PROTOBUF_ASSUME(!value || _impl_.d88_ != nullptr);
  return value;
}
inline void ImageReaderProto::clear_d88() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.d88_ != nullptr) _impl_.d88_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline const ::D88InputProto& ImageReaderProto::_internal_d88() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::D88InputProto* p = _impl_.d88_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::D88InputProto>(&::D88InputProto_globals_);
}
inline const ::D88InputProto& ImageReaderProto::d88() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.d88)
  return _internal_d88();
}
inline void ImageReaderProto::unsafe_arena_set_allocated_d88(
    ::D88InputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.d88_);
  }
  _impl_.d88_ = reinterpret_cast<::D88InputProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ImageReaderProto.d88)
}
inline ::D88InputProto* PROTOBUF_NULLABLE ImageReaderProto::release_d88() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::D88InputProto* released = _impl_.d88_;
  _impl_.d88_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::D88InputProto* PROTOBUF_NULLABLE ImageReaderProto::unsafe_arena_release_d88() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.d88)

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::D88InputProto* temp = _impl_.d88_;
  _impl_.d88_ = nullptr;
  return temp;
}
inline ::D88InputProto* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_d88() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.d88_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::D88InputProto>(GetArena());
    _impl_.d88_ = reinterpret_cast<::D88InputProto*>(p);
  }
  return _impl_.d88_;
}
inline ::D88InputProto* PROTOBUF_NONNULL ImageReaderProto::mutable_d88()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::D88InputProto* _msg = _internal_mutable_d88();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.d88)
  return _msg;
}
inline void ImageReaderProto::set_allocated_d88(::D88InputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.d88_);
  }

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

  _impl_.d88_ = reinterpret_cast<::D88InputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.d88)
}

// optional .NfdInputProto nfd = 12 [json_name = "nfd"];
inline bool ImageReaderProto::has_nfd() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  PROTOBUF_ASSUME(!value || _impl_.nfd_ != nullptr);
  return value;
}
inline void ImageReaderProto::clear_nfd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.nfd_ != nullptr) _impl_.nfd_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline const ::NfdInputProto& ImageReaderProto::_internal_nfd() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::NfdInputProto* p = _impl_.nfd_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::NfdInputProto>(&::NfdInputProto_globals_);
}
inline const ::NfdInputProto& ImageReaderProto::nfd() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageReaderProto.nfd)
  return _internal_nfd();
}
inline void ImageReaderProto::unsafe_arena_set_allocated_nfd(
    ::NfdInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.nfd_);
  }
  _impl_.nfd_ = reinterpret_cast<::NfdInputProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ImageReaderProto.nfd)
}
inline ::NfdInputProto* PROTOBUF_NULLABLE ImageReaderProto::release_nfd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::NfdInputProto* released = _impl_.nfd_;
  _impl_.nfd_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::NfdInputProto* PROTOBUF_NULLABLE ImageReaderProto::unsafe_arena_release_nfd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageReaderProto.nfd)

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::NfdInputProto* temp = _impl_.nfd_;
  _impl_.nfd_ = nullptr;
  return temp;
}
inline ::NfdInputProto* PROTOBUF_NONNULL ImageReaderProto::_internal_mutable_nfd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.nfd_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::NfdInputProto>(GetArena());
    _impl_.nfd_ = reinterpret_cast<::NfdInputProto*>(p);
  }
  return _impl_.nfd_;
}
inline ::NfdInputProto* PROTOBUF_NONNULL ImageReaderProto::mutable_nfd()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::NfdInputProto* _msg = _internal_mutable_nfd();
  // @@protoc_insertion_point(field_mutable:ImageReaderProto.nfd)
  return _msg;
}
inline void ImageReaderProto::set_allocated_nfd(::NfdInputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.nfd_);
  }

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

  _impl_.nfd_ = reinterpret_cast<::NfdInputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageReaderProto.nfd)
}

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

// @@protoc_insertion_point(namespace_scope)


// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // lib_2fimagereader_2fimagereader_2eproto_2epb_2eh
