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

#ifndef lib_2fimagewriter_2fimagewriter_2eproto_2epb_2eh
#define lib_2fimagewriter_2fimagewriter_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/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
#include "lib/imagereader/imagereader.pb.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_2fimagewriter_2fimagewriter_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_lib_2fimagewriter_2fimagewriter_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_lib_2fimagewriter_2fimagewriter_2eproto;
}  // extern "C"
enum ImdOutputProto_DataRate : int;
extern const uint32_t ImdOutputProto_DataRate_internal_data_[];
enum ImdOutputProto_RecordingMode : int;
extern const uint32_t ImdOutputProto_RecordingMode_internal_data_[];
enum LDBSOutputProto_DataRate : int;
extern const uint32_t LDBSOutputProto_DataRate_internal_data_[];
enum LDBSOutputProto_RecordingMode : int;
extern const uint32_t LDBSOutputProto_RecordingMode_internal_data_[];
class D64OutputProto;
struct D64OutputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern D64OutputProtoGlobalsTypeInternal D64OutputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull D64OutputProto_class_data_;
#else
extern const D64OutputProtoGlobalsTypeInternal D64OutputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class D88OutputProto;
struct D88OutputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern D88OutputProtoGlobalsTypeInternal D88OutputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull D88OutputProto_class_data_;
#else
extern const D88OutputProtoGlobalsTypeInternal D88OutputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class DiskCopyOutputProto;
struct DiskCopyOutputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DiskCopyOutputProtoGlobalsTypeInternal DiskCopyOutputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull DiskCopyOutputProto_class_data_;
#else
extern const DiskCopyOutputProtoGlobalsTypeInternal DiskCopyOutputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ImageWriterProto;
struct ImageWriterProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ImageWriterProtoGlobalsTypeInternal ImageWriterProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull ImageWriterProto_class_data_;
#else
extern const ImageWriterProtoGlobalsTypeInternal ImageWriterProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ImdOutputProto;
struct ImdOutputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ImdOutputProtoGlobalsTypeInternal ImdOutputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull ImdOutputProto_class_data_;
#else
extern const ImdOutputProtoGlobalsTypeInternal ImdOutputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class LDBSOutputProto;
struct LDBSOutputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern LDBSOutputProtoGlobalsTypeInternal LDBSOutputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull LDBSOutputProto_class_data_;
#else
extern const LDBSOutputProtoGlobalsTypeInternal LDBSOutputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class NsiOutputProto;
struct NsiOutputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern NsiOutputProtoGlobalsTypeInternal NsiOutputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull NsiOutputProto_class_data_;
#else
extern const NsiOutputProtoGlobalsTypeInternal NsiOutputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class RawOutputProto;
struct RawOutputProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern RawOutputProtoGlobalsTypeInternal RawOutputProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull RawOutputProto_class_data_;
#else
extern const RawOutputProtoGlobalsTypeInternal RawOutputProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::ImdOutputProto_DataRate_internal_data_>
    internal::EnumTraitsImpl::value<::ImdOutputProto_DataRate>;
template <>
internal::EnumTraitsT<::ImdOutputProto_RecordingMode_internal_data_>
    internal::EnumTraitsImpl::value<::ImdOutputProto_RecordingMode>;
template <>
internal::EnumTraitsT<::LDBSOutputProto_DataRate_internal_data_>
    internal::EnumTraitsImpl::value<::LDBSOutputProto_DataRate>;
template <>
internal::EnumTraitsT<::LDBSOutputProto_RecordingMode_internal_data_>
    internal::EnumTraitsImpl::value<::LDBSOutputProto_RecordingMode>;
}  // namespace protobuf
}  // namespace google

enum LDBSOutputProto_DataRate : int {
  LDBSOutputProto_DataRate_RATE_HD = 0,
  LDBSOutputProto_DataRate_RATE_DD = 1,
  LDBSOutputProto_DataRate_RATE_SD = 2,
  LDBSOutputProto_DataRate_RATE_ED = 3,
  LDBSOutputProto_DataRate_RATE_GUESS = -1,
};

extern const uint32_t LDBSOutputProto_DataRate_internal_data_[];
inline constexpr LDBSOutputProto_DataRate LDBSOutputProto_DataRate_DataRate_MIN =
    static_cast<LDBSOutputProto_DataRate>(-1);
inline constexpr LDBSOutputProto_DataRate LDBSOutputProto_DataRate_DataRate_MAX =
    static_cast<LDBSOutputProto_DataRate>(3);
[[nodiscard]] inline bool LDBSOutputProto_DataRate_IsValid(int value) {
  return -1 <= value && value <= 3;
}
inline constexpr int LDBSOutputProto_DataRate_DataRate_ARRAYSIZE = 3 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
LDBSOutputProto_DataRate_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(LDBSOutputProto_DataRate) {
  return LDBSOutputProto_DataRate_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& LDBSOutputProto_DataRate_Name(T value) {
  static_assert(::std::is_same<T, LDBSOutputProto_DataRate>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to DataRate_Name().");
  return LDBSOutputProto_DataRate_Name(static_cast<LDBSOutputProto_DataRate>(value));
}
template <>
[[nodiscard]] inline const ::std::string& LDBSOutputProto_DataRate_Name(LDBSOutputProto_DataRate value) {
  return ::google::protobuf::internal::NameOfDenseEnum<LDBSOutputProto_DataRate_descriptor, -1, 3>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool LDBSOutputProto_DataRate_Parse(
    ::absl::string_view name, LDBSOutputProto_DataRate* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<LDBSOutputProto_DataRate>(LDBSOutputProto_DataRate_descriptor(), name,
                                           value);
}
enum LDBSOutputProto_RecordingMode : int {
  LDBSOutputProto_RecordingMode_RECMODE_MFM = 0,
  LDBSOutputProto_RecordingMode_RECMODE_FM = 1,
  LDBSOutputProto_RecordingMode_RECMODE_GCR_MAC = 18,
  LDBSOutputProto_RecordingMode_RECMODE_GCR_PRODOS = 20,
  LDBSOutputProto_RecordingMode_RECMODE_GCR_LISA = 34,
  LDBSOutputProto_RecordingMode_RECMODE_GUESS = -1,
};

extern const uint32_t LDBSOutputProto_RecordingMode_internal_data_[];
inline constexpr LDBSOutputProto_RecordingMode LDBSOutputProto_RecordingMode_RecordingMode_MIN =
    static_cast<LDBSOutputProto_RecordingMode>(-1);
inline constexpr LDBSOutputProto_RecordingMode LDBSOutputProto_RecordingMode_RecordingMode_MAX =
    static_cast<LDBSOutputProto_RecordingMode>(34);
[[nodiscard]] inline bool LDBSOutputProto_RecordingMode_IsValid(int value) {
  return ::google::protobuf::internal::ValidateEnum(value, LDBSOutputProto_RecordingMode_internal_data_);
}
inline constexpr int LDBSOutputProto_RecordingMode_RecordingMode_ARRAYSIZE = 34 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
LDBSOutputProto_RecordingMode_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(LDBSOutputProto_RecordingMode) {
  return LDBSOutputProto_RecordingMode_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& LDBSOutputProto_RecordingMode_Name(T value) {
  static_assert(::std::is_same<T, LDBSOutputProto_RecordingMode>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to RecordingMode_Name().");
  return ::google::protobuf::internal::NameOfEnum(LDBSOutputProto_RecordingMode_descriptor(), value);
}
[[nodiscard]] inline bool LDBSOutputProto_RecordingMode_Parse(
    ::absl::string_view name, LDBSOutputProto_RecordingMode* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<LDBSOutputProto_RecordingMode>(LDBSOutputProto_RecordingMode_descriptor(), name,
                                           value);
}
enum ImdOutputProto_DataRate : int {
  ImdOutputProto_DataRate_RATE_HD = 0,
  ImdOutputProto_DataRate_RATE_DD = 1,
  ImdOutputProto_DataRate_RATE_SD = 2,
  ImdOutputProto_DataRate_RATE_GUESS = -1,
};

extern const uint32_t ImdOutputProto_DataRate_internal_data_[];
inline constexpr ImdOutputProto_DataRate ImdOutputProto_DataRate_DataRate_MIN =
    static_cast<ImdOutputProto_DataRate>(-1);
inline constexpr ImdOutputProto_DataRate ImdOutputProto_DataRate_DataRate_MAX =
    static_cast<ImdOutputProto_DataRate>(2);
[[nodiscard]] inline bool ImdOutputProto_DataRate_IsValid(int value) {
  return -1 <= value && value <= 2;
}
inline constexpr int ImdOutputProto_DataRate_DataRate_ARRAYSIZE = 2 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
ImdOutputProto_DataRate_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(ImdOutputProto_DataRate) {
  return ImdOutputProto_DataRate_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& ImdOutputProto_DataRate_Name(T value) {
  static_assert(::std::is_same<T, ImdOutputProto_DataRate>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to DataRate_Name().");
  return ImdOutputProto_DataRate_Name(static_cast<ImdOutputProto_DataRate>(value));
}
template <>
[[nodiscard]] inline const ::std::string& ImdOutputProto_DataRate_Name(ImdOutputProto_DataRate value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ImdOutputProto_DataRate_descriptor, -1, 2>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool ImdOutputProto_DataRate_Parse(
    ::absl::string_view name, ImdOutputProto_DataRate* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<ImdOutputProto_DataRate>(ImdOutputProto_DataRate_descriptor(), name,
                                           value);
}
enum ImdOutputProto_RecordingMode : int {
  ImdOutputProto_RecordingMode_RECMODE_MFM = 0,
  ImdOutputProto_RecordingMode_RECMODE_FM = 1,
  ImdOutputProto_RecordingMode_RECMODE_GUESS = -1,
};

extern const uint32_t ImdOutputProto_RecordingMode_internal_data_[];
inline constexpr ImdOutputProto_RecordingMode ImdOutputProto_RecordingMode_RecordingMode_MIN =
    static_cast<ImdOutputProto_RecordingMode>(-1);
inline constexpr ImdOutputProto_RecordingMode ImdOutputProto_RecordingMode_RecordingMode_MAX =
    static_cast<ImdOutputProto_RecordingMode>(1);
[[nodiscard]] inline bool ImdOutputProto_RecordingMode_IsValid(int value) {
  return -1 <= value && value <= 1;
}
inline constexpr int ImdOutputProto_RecordingMode_RecordingMode_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
ImdOutputProto_RecordingMode_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(ImdOutputProto_RecordingMode) {
  return ImdOutputProto_RecordingMode_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& ImdOutputProto_RecordingMode_Name(T value) {
  static_assert(::std::is_same<T, ImdOutputProto_RecordingMode>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to RecordingMode_Name().");
  return ImdOutputProto_RecordingMode_Name(static_cast<ImdOutputProto_RecordingMode>(value));
}
template <>
[[nodiscard]] inline const ::std::string& ImdOutputProto_RecordingMode_Name(ImdOutputProto_RecordingMode value) {
  return ::google::protobuf::internal::NameOfDenseEnum<ImdOutputProto_RecordingMode_descriptor, -1, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool ImdOutputProto_RecordingMode_Parse(
    ::absl::string_view name, ImdOutputProto_RecordingMode* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<ImdOutputProto_RecordingMode>(ImdOutputProto_RecordingMode_descriptor(), name,
                                           value);
}
using ::google::protobuf::internal::generated_enum::AbslParseFlag;
using ::google::protobuf::internal::generated_enum::AbslUnparseFlag;

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


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

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

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

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

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

  inline RawOutputProto(const RawOutputProto& from) : RawOutputProto(nullptr, from) {}
  inline RawOutputProto(RawOutputProto&& from) noexcept : RawOutputProto(nullptr, ::std::move(from)) {}
  inline RawOutputProto& operator=(const RawOutputProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline RawOutputProto& operator=(RawOutputProto&& 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 RawOutputProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<RawOutputProto>(&RawOutputProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(RawOutputProto& a, RawOutputProto& b) { a.Swap(&b); }
  inline void Swap(RawOutputProto* 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(RawOutputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  explicit RawOutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  RawOutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RawOutputProto& from);
  RawOutputProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RawOutputProto&& from) noexcept
      : RawOutputProto(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:RawOutputProto)
 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_2fimagewriter_2fimagewriter_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline NsiOutputProto(const NsiOutputProto& from) : NsiOutputProto(nullptr, from) {}
  inline NsiOutputProto(NsiOutputProto&& from) noexcept : NsiOutputProto(nullptr, ::std::move(from)) {}
  inline NsiOutputProto& operator=(const NsiOutputProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline NsiOutputProto& operator=(NsiOutputProto&& 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 NsiOutputProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<NsiOutputProto>(&NsiOutputProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(NsiOutputProto& a, NsiOutputProto& b) { a.Swap(&b); }
  inline void Swap(NsiOutputProto* 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(NsiOutputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  explicit NsiOutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  NsiOutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NsiOutputProto& from);
  NsiOutputProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, NsiOutputProto&& from) noexcept
      : NsiOutputProto(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:NsiOutputProto)
 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_2fimagewriter_2fimagewriter_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline LDBSOutputProto(const LDBSOutputProto& from) : LDBSOutputProto(nullptr, from) {}
  inline LDBSOutputProto(LDBSOutputProto&& from) noexcept : LDBSOutputProto(nullptr, ::std::move(from)) {}
  inline LDBSOutputProto& operator=(const LDBSOutputProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline LDBSOutputProto& operator=(LDBSOutputProto&& 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 LDBSOutputProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<LDBSOutputProto>(&LDBSOutputProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(LDBSOutputProto& a, LDBSOutputProto& b) { a.Swap(&b); }
  inline void Swap(LDBSOutputProto* 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(LDBSOutputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] LDBSOutputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<LDBSOutputProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const LDBSOutputProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const LDBSOutputProto& from) { LDBSOutputProto::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(LDBSOutputProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "LDBSOutputProto"; }

  explicit LDBSOutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  LDBSOutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LDBSOutputProto& from);
  LDBSOutputProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, LDBSOutputProto&& from) noexcept
      : LDBSOutputProto(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 ----------------------------------------------------
  using DataRate = LDBSOutputProto_DataRate;
  static constexpr DataRate RATE_HD = LDBSOutputProto_DataRate_RATE_HD;
  static constexpr DataRate RATE_DD = LDBSOutputProto_DataRate_RATE_DD;
  static constexpr DataRate RATE_SD = LDBSOutputProto_DataRate_RATE_SD;
  static constexpr DataRate RATE_ED = LDBSOutputProto_DataRate_RATE_ED;
  static constexpr DataRate RATE_GUESS = LDBSOutputProto_DataRate_RATE_GUESS;
  [[nodiscard]] static inline bool DataRate_IsValid(int value) {
    return LDBSOutputProto_DataRate_IsValid(value);
  }
  static constexpr DataRate DataRate_MIN = LDBSOutputProto_DataRate_DataRate_MIN;
  static constexpr DataRate DataRate_MAX = LDBSOutputProto_DataRate_DataRate_MAX;
  static constexpr int DataRate_ARRAYSIZE = LDBSOutputProto_DataRate_DataRate_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DataRate_descriptor() {
    return LDBSOutputProto_DataRate_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& DataRate_Name(T value) {
    return LDBSOutputProto_DataRate_Name(value);
  }
  [[nodiscard]] static inline bool DataRate_Parse(
      ::absl::string_view name, DataRate* PROTOBUF_NONNULL value) {
    return LDBSOutputProto_DataRate_Parse(name, value);
  }
  using RecordingMode = LDBSOutputProto_RecordingMode;
  static constexpr RecordingMode RECMODE_MFM = LDBSOutputProto_RecordingMode_RECMODE_MFM;
  static constexpr RecordingMode RECMODE_FM = LDBSOutputProto_RecordingMode_RECMODE_FM;
  static constexpr RecordingMode RECMODE_GCR_MAC = LDBSOutputProto_RecordingMode_RECMODE_GCR_MAC;
  static constexpr RecordingMode RECMODE_GCR_PRODOS = LDBSOutputProto_RecordingMode_RECMODE_GCR_PRODOS;
  static constexpr RecordingMode RECMODE_GCR_LISA = LDBSOutputProto_RecordingMode_RECMODE_GCR_LISA;
  static constexpr RecordingMode RECMODE_GUESS = LDBSOutputProto_RecordingMode_RECMODE_GUESS;
  [[nodiscard]] static inline bool RecordingMode_IsValid(int value) {
    return LDBSOutputProto_RecordingMode_IsValid(value);
  }
  static constexpr RecordingMode RecordingMode_MIN = LDBSOutputProto_RecordingMode_RecordingMode_MIN;
  static constexpr RecordingMode RecordingMode_MAX = LDBSOutputProto_RecordingMode_RecordingMode_MAX;
  static constexpr int RecordingMode_ARRAYSIZE = LDBSOutputProto_RecordingMode_RecordingMode_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RecordingMode_descriptor() {
    return LDBSOutputProto_RecordingMode_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& RecordingMode_Name(T value) {
    return LDBSOutputProto_RecordingMode_Name(value);
  }
  [[nodiscard]] static inline bool RecordingMode_Parse(
      ::absl::string_view name, RecordingMode* PROTOBUF_NONNULL value) {
    return LDBSOutputProto_RecordingMode_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kDataRateFieldNumber = 1,
    kRecordingModeFieldNumber = 2,
  };
  // optional .LDBSOutputProto.DataRate data_rate = 1 [default = RATE_GUESS, json_name = "dataRate", (.help) = "data rate to use in LDBS file"];
  [[nodiscard]] bool has_data_rate() const;
  void clear_data_rate() ;
  [[nodiscard]] ::LDBSOutputProto_DataRate data_rate() const;
  void set_data_rate(::LDBSOutputProto_DataRate value);

  private:
  ::LDBSOutputProto_DataRate _internal_data_rate() const;
  void _internal_set_data_rate(::LDBSOutputProto_DataRate value);

  public:
  // optional .LDBSOutputProto.RecordingMode recording_mode = 2 [default = RECMODE_GUESS, json_name = "recordingMode", (.help) = "recording mode to use in LDBS file"];
  [[nodiscard]] bool has_recording_mode() const;
  void clear_recording_mode() ;
  [[nodiscard]] ::LDBSOutputProto_RecordingMode recording_mode() const;
  void set_recording_mode(::LDBSOutputProto_RecordingMode value);

  private:
  ::LDBSOutputProto_RecordingMode _internal_recording_mode() const;
  void _internal_set_recording_mode(::LDBSOutputProto_RecordingMode value);

  public:
  // @@protoc_insertion_point(class_scope:LDBSOutputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<1, 2,
                          2, 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 LDBSOutputProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int data_rate_;
    int recording_mode_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fimagewriter_2fimagewriter_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline ImdOutputProto(const ImdOutputProto& from) : ImdOutputProto(nullptr, from) {}
  inline ImdOutputProto(ImdOutputProto&& from) noexcept : ImdOutputProto(nullptr, ::std::move(from)) {}
  inline ImdOutputProto& operator=(const ImdOutputProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ImdOutputProto& operator=(ImdOutputProto&& 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 ImdOutputProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ImdOutputProto>(&ImdOutputProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(ImdOutputProto& a, ImdOutputProto& b) { a.Swap(&b); }
  inline void Swap(ImdOutputProto* 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(ImdOutputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ImdOutputProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<ImdOutputProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const ImdOutputProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const ImdOutputProto& from) { ImdOutputProto::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(ImdOutputProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "ImdOutputProto"; }

  explicit ImdOutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ImdOutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ImdOutputProto& from);
  ImdOutputProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ImdOutputProto&& from) noexcept
      : ImdOutputProto(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 ----------------------------------------------------
  using DataRate = ImdOutputProto_DataRate;
  static constexpr DataRate RATE_HD = ImdOutputProto_DataRate_RATE_HD;
  static constexpr DataRate RATE_DD = ImdOutputProto_DataRate_RATE_DD;
  static constexpr DataRate RATE_SD = ImdOutputProto_DataRate_RATE_SD;
  static constexpr DataRate RATE_GUESS = ImdOutputProto_DataRate_RATE_GUESS;
  [[nodiscard]] static inline bool DataRate_IsValid(int value) {
    return ImdOutputProto_DataRate_IsValid(value);
  }
  static constexpr DataRate DataRate_MIN = ImdOutputProto_DataRate_DataRate_MIN;
  static constexpr DataRate DataRate_MAX = ImdOutputProto_DataRate_DataRate_MAX;
  static constexpr int DataRate_ARRAYSIZE = ImdOutputProto_DataRate_DataRate_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL DataRate_descriptor() {
    return ImdOutputProto_DataRate_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& DataRate_Name(T value) {
    return ImdOutputProto_DataRate_Name(value);
  }
  [[nodiscard]] static inline bool DataRate_Parse(
      ::absl::string_view name, DataRate* PROTOBUF_NONNULL value) {
    return ImdOutputProto_DataRate_Parse(name, value);
  }
  using RecordingMode = ImdOutputProto_RecordingMode;
  static constexpr RecordingMode RECMODE_MFM = ImdOutputProto_RecordingMode_RECMODE_MFM;
  static constexpr RecordingMode RECMODE_FM = ImdOutputProto_RecordingMode_RECMODE_FM;
  static constexpr RecordingMode RECMODE_GUESS = ImdOutputProto_RecordingMode_RECMODE_GUESS;
  [[nodiscard]] static inline bool RecordingMode_IsValid(int value) {
    return ImdOutputProto_RecordingMode_IsValid(value);
  }
  static constexpr RecordingMode RecordingMode_MIN = ImdOutputProto_RecordingMode_RecordingMode_MIN;
  static constexpr RecordingMode RecordingMode_MAX = ImdOutputProto_RecordingMode_RecordingMode_MAX;
  static constexpr int RecordingMode_ARRAYSIZE = ImdOutputProto_RecordingMode_RecordingMode_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RecordingMode_descriptor() {
    return ImdOutputProto_RecordingMode_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& RecordingMode_Name(T value) {
    return ImdOutputProto_RecordingMode_Name(value);
  }
  [[nodiscard]] static inline bool RecordingMode_Parse(
      ::absl::string_view name, RecordingMode* PROTOBUF_NONNULL value) {
    return ImdOutputProto_RecordingMode_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kCommentFieldNumber = 3,
    kDataRateFieldNumber = 1,
    kRecordingModeFieldNumber = 2,
  };
  // optional string comment = 3 [json_name = "comment", (.help) = "comment to set in IMD file"];
  [[nodiscard]] bool has_comment() const;
  void clear_comment() ;
  [[nodiscard]] const ::std::string& comment() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_comment(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_comment();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_comment();
  void set_allocated_comment(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_comment() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_comment();

  public:
  // optional .ImdOutputProto.DataRate data_rate = 1 [default = RATE_GUESS, json_name = "dataRate", (.help) = "data rate to use in IMD file"];
  [[nodiscard]] bool has_data_rate() const;
  void clear_data_rate() ;
  [[nodiscard]] ::ImdOutputProto_DataRate data_rate() const;
  void set_data_rate(::ImdOutputProto_DataRate value);

  private:
  ::ImdOutputProto_DataRate _internal_data_rate() const;
  void _internal_set_data_rate(::ImdOutputProto_DataRate value);

  public:
  // optional .ImdOutputProto.RecordingMode recording_mode = 2 [default = RECMODE_GUESS, json_name = "recordingMode", (.help) = "recording mode (FM or MFM encoding) to use in IMD file"];
  [[nodiscard]] bool has_recording_mode() const;
  void clear_recording_mode() ;
  [[nodiscard]] ::ImdOutputProto_RecordingMode recording_mode() const;
  void set_recording_mode(::ImdOutputProto_RecordingMode value);

  private:
  ::ImdOutputProto_RecordingMode _internal_recording_mode() const;
  void _internal_set_recording_mode(::ImdOutputProto_RecordingMode value);

  public:
  // @@protoc_insertion_point(class_scope:ImdOutputProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          2, 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 ImdOutputProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr comment_;
    int data_rate_;
    int recording_mode_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fimagewriter_2fimagewriter_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline DiskCopyOutputProto(const DiskCopyOutputProto& from) : DiskCopyOutputProto(nullptr, from) {}
  inline DiskCopyOutputProto(DiskCopyOutputProto&& from) noexcept : DiskCopyOutputProto(nullptr, ::std::move(from)) {}
  inline DiskCopyOutputProto& operator=(const DiskCopyOutputProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline DiskCopyOutputProto& operator=(DiskCopyOutputProto&& 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 DiskCopyOutputProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<DiskCopyOutputProto>(&DiskCopyOutputProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(DiskCopyOutputProto& a, DiskCopyOutputProto& b) { a.Swap(&b); }
  inline void Swap(DiskCopyOutputProto* 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(DiskCopyOutputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  explicit DiskCopyOutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  DiskCopyOutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DiskCopyOutputProto& from);
  DiskCopyOutputProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DiskCopyOutputProto&& from) noexcept
      : DiskCopyOutputProto(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:DiskCopyOutputProto)
 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_2fimagewriter_2fimagewriter_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline D88OutputProto(const D88OutputProto& from) : D88OutputProto(nullptr, from) {}
  inline D88OutputProto(D88OutputProto&& from) noexcept : D88OutputProto(nullptr, ::std::move(from)) {}
  inline D88OutputProto& operator=(const D88OutputProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline D88OutputProto& operator=(D88OutputProto&& 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 D88OutputProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<D88OutputProto>(&D88OutputProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(D88OutputProto& a, D88OutputProto& b) { a.Swap(&b); }
  inline void Swap(D88OutputProto* 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(D88OutputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  explicit D88OutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  D88OutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const D88OutputProto& from);
  D88OutputProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, D88OutputProto&& from) noexcept
      : D88OutputProto(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:D88OutputProto)
 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_2fimagewriter_2fimagewriter_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline D64OutputProto(const D64OutputProto& from) : D64OutputProto(nullptr, from) {}
  inline D64OutputProto(D64OutputProto&& from) noexcept : D64OutputProto(nullptr, ::std::move(from)) {}
  inline D64OutputProto& operator=(const D64OutputProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline D64OutputProto& operator=(D64OutputProto&& 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 D64OutputProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<D64OutputProto>(&D64OutputProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(D64OutputProto& a, D64OutputProto& b) { a.Swap(&b); }
  inline void Swap(D64OutputProto* 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(D64OutputProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  explicit D64OutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  D64OutputProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const D64OutputProto& from);
  D64OutputProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, D64OutputProto&& from) noexcept
      : D64OutputProto(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:D64OutputProto)
 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_2fimagewriter_2fimagewriter_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline ImageWriterProto(const ImageWriterProto& from) : ImageWriterProto(nullptr, from) {}
  inline ImageWriterProto(ImageWriterProto&& from) noexcept : ImageWriterProto(nullptr, ::std::move(from)) {}
  inline ImageWriterProto& operator=(const ImageWriterProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ImageWriterProto& operator=(ImageWriterProto&& 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 ImageWriterProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ImageWriterProto>(&ImageWriterProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(ImageWriterProto& a, ImageWriterProto& b) { a.Swap(&b); }
  inline void Swap(ImageWriterProto* 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(ImageWriterProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ImageWriterProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<ImageWriterProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const ImageWriterProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const ImageWriterProto& from) { ImageWriterProto::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(ImageWriterProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "ImageWriterProto"; }

  explicit ImageWriterProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ImageWriterProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ImageWriterProto& from);
  ImageWriterProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ImageWriterProto&& from) noexcept
      : ImageWriterProto(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,
    kD64FieldNumber = 3,
    kLdbsFieldNumber = 4,
    kDiskcopyFieldNumber = 5,
    kNsiFieldNumber = 6,
    kRawFieldNumber = 7,
    kD88FieldNumber = 8,
    kImdFieldNumber = 9,
    kTypeFieldNumber = 10,
  };
  // optional string filename = 1 [json_name = "filename", (.help) = "filename of output 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 .D64OutputProto d64 = 3 [json_name = "d64"];
  [[nodiscard]] bool has_d64() const;
  void clear_d64() ;
  [[nodiscard]] const ::D64OutputProto& d64() const;
  [[nodiscard]] ::D64OutputProto* PROTOBUF_NULLABLE release_d64();
  ::D64OutputProto* PROTOBUF_NONNULL mutable_d64();
  void set_allocated_d64(::D64OutputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_d64(::D64OutputProto* PROTOBUF_NULLABLE value);
  ::D64OutputProto* PROTOBUF_NULLABLE unsafe_arena_release_d64();

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

  public:
  // optional .LDBSOutputProto ldbs = 4 [json_name = "ldbs"];
  [[nodiscard]] bool has_ldbs() const;
  void clear_ldbs() ;
  [[nodiscard]] const ::LDBSOutputProto& ldbs() const;
  [[nodiscard]] ::LDBSOutputProto* PROTOBUF_NULLABLE release_ldbs();
  ::LDBSOutputProto* PROTOBUF_NONNULL mutable_ldbs();
  void set_allocated_ldbs(::LDBSOutputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_ldbs(::LDBSOutputProto* PROTOBUF_NULLABLE value);
  ::LDBSOutputProto* PROTOBUF_NULLABLE unsafe_arena_release_ldbs();

  private:
  const ::LDBSOutputProto& _internal_ldbs() const;
  ::LDBSOutputProto* PROTOBUF_NONNULL _internal_mutable_ldbs();

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

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

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

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

  public:
  // optional .RawOutputProto raw = 7 [json_name = "raw"];
  [[nodiscard]] bool has_raw() const;
  void clear_raw() ;
  [[nodiscard]] const ::RawOutputProto& raw() const;
  [[nodiscard]] ::RawOutputProto* PROTOBUF_NULLABLE release_raw();
  ::RawOutputProto* PROTOBUF_NONNULL mutable_raw();
  void set_allocated_raw(::RawOutputProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_raw(::RawOutputProto* PROTOBUF_NULLABLE value);
  ::RawOutputProto* PROTOBUF_NULLABLE unsafe_arena_release_raw();

  private:
  const ::RawOutputProto& _internal_raw() const;
  ::RawOutputProto* PROTOBUF_NONNULL _internal_mutable_raw();

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

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

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

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

  public:
  // optional .ImageReaderWriterType type = 10 [default = IMAGETYPE_NOT_SET, json_name = "type", (.help) = "image writer 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:ImageWriterProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<4, 10,
                          9, 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 ImageWriterProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr filename_;
    ::ImgInputOutputProto* PROTOBUF_NULLABLE img_;
    ::D64OutputProto* PROTOBUF_NULLABLE d64_;
    ::LDBSOutputProto* PROTOBUF_NULLABLE ldbs_;
    ::DiskCopyOutputProto* PROTOBUF_NULLABLE diskcopy_;
    ::NsiOutputProto* PROTOBUF_NULLABLE nsi_;
    ::RawOutputProto* PROTOBUF_NULLABLE raw_;
    ::D88OutputProto* PROTOBUF_NULLABLE d88_;
    ::ImdOutputProto* PROTOBUF_NULLABLE imd_;
    int type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fimagewriter_2fimagewriter_2eproto;
};

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




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


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

// D64OutputProto

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

// LDBSOutputProto

// optional .LDBSOutputProto.DataRate data_rate = 1 [default = RATE_GUESS, json_name = "dataRate", (.help) = "data rate to use in LDBS file"];
inline bool LDBSOutputProto::has_data_rate() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void LDBSOutputProto::clear_data_rate() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.data_rate_ = -1;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::LDBSOutputProto_DataRate LDBSOutputProto::data_rate() const {
  // @@protoc_insertion_point(field_get:LDBSOutputProto.data_rate)
  return _internal_data_rate();
}
inline void LDBSOutputProto::set_data_rate(::LDBSOutputProto_DataRate value) {
  _internal_set_data_rate(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:LDBSOutputProto.data_rate)
}
inline ::LDBSOutputProto_DataRate LDBSOutputProto::_internal_data_rate() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::LDBSOutputProto_DataRate>(_impl_.data_rate_);
}
inline void LDBSOutputProto::_internal_set_data_rate(::LDBSOutputProto_DataRate value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::LDBSOutputProto_DataRate_internal_data_));
                                          _impl_.data_rate_ = value;
}

// optional .LDBSOutputProto.RecordingMode recording_mode = 2 [default = RECMODE_GUESS, json_name = "recordingMode", (.help) = "recording mode to use in LDBS file"];
inline bool LDBSOutputProto::has_recording_mode() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void LDBSOutputProto::clear_recording_mode() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.recording_mode_ = -1;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::LDBSOutputProto_RecordingMode LDBSOutputProto::recording_mode() const {
  // @@protoc_insertion_point(field_get:LDBSOutputProto.recording_mode)
  return _internal_recording_mode();
}
inline void LDBSOutputProto::set_recording_mode(::LDBSOutputProto_RecordingMode value) {
  _internal_set_recording_mode(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:LDBSOutputProto.recording_mode)
}
inline ::LDBSOutputProto_RecordingMode LDBSOutputProto::_internal_recording_mode() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::LDBSOutputProto_RecordingMode>(_impl_.recording_mode_);
}
inline void LDBSOutputProto::_internal_set_recording_mode(::LDBSOutputProto_RecordingMode value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::LDBSOutputProto_RecordingMode_internal_data_));
                                          _impl_.recording_mode_ = value;
}

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

// DiskCopyOutputProto

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

// NsiOutputProto

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

// RawOutputProto

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

// D88OutputProto

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

// ImdOutputProto

// optional .ImdOutputProto.DataRate data_rate = 1 [default = RATE_GUESS, json_name = "dataRate", (.help) = "data rate to use in IMD file"];
inline bool ImdOutputProto::has_data_rate() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void ImdOutputProto::clear_data_rate() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.data_rate_ = -1;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::ImdOutputProto_DataRate ImdOutputProto::data_rate() const {
  // @@protoc_insertion_point(field_get:ImdOutputProto.data_rate)
  return _internal_data_rate();
}
inline void ImdOutputProto::set_data_rate(::ImdOutputProto_DataRate value) {
  _internal_set_data_rate(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:ImdOutputProto.data_rate)
}
inline ::ImdOutputProto_DataRate ImdOutputProto::_internal_data_rate() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::ImdOutputProto_DataRate>(_impl_.data_rate_);
}
inline void ImdOutputProto::_internal_set_data_rate(::ImdOutputProto_DataRate value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::ImdOutputProto_DataRate_internal_data_));
                                          _impl_.data_rate_ = value;
}

// optional .ImdOutputProto.RecordingMode recording_mode = 2 [default = RECMODE_GUESS, json_name = "recordingMode", (.help) = "recording mode (FM or MFM encoding) to use in IMD file"];
inline bool ImdOutputProto::has_recording_mode() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void ImdOutputProto::clear_recording_mode() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.recording_mode_ = -1;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::ImdOutputProto_RecordingMode ImdOutputProto::recording_mode() const {
  // @@protoc_insertion_point(field_get:ImdOutputProto.recording_mode)
  return _internal_recording_mode();
}
inline void ImdOutputProto::set_recording_mode(::ImdOutputProto_RecordingMode value) {
  _internal_set_recording_mode(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:ImdOutputProto.recording_mode)
}
inline ::ImdOutputProto_RecordingMode ImdOutputProto::_internal_recording_mode() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::ImdOutputProto_RecordingMode>(_impl_.recording_mode_);
}
inline void ImdOutputProto::_internal_set_recording_mode(::ImdOutputProto_RecordingMode value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::ImdOutputProto_RecordingMode_internal_data_));
                                          _impl_.recording_mode_ = value;
}

// optional string comment = 3 [json_name = "comment", (.help) = "comment to set in IMD file"];
inline bool ImdOutputProto::has_comment() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void ImdOutputProto::clear_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.comment_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& ImdOutputProto::comment() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImdOutputProto.comment)
  return _internal_comment();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ImdOutputProto::set_comment(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.comment_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:ImdOutputProto.comment)
}
inline ::std::string* PROTOBUF_NONNULL ImdOutputProto::mutable_comment()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_comment();
  // @@protoc_insertion_point(field_mutable:ImdOutputProto.comment)
  return _s;
}
inline const ::std::string& ImdOutputProto::_internal_comment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.comment_.Get();
}
inline void ImdOutputProto::_internal_set_comment(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.comment_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ImdOutputProto::_internal_mutable_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.comment_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ImdOutputProto::release_comment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImdOutputProto.comment)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.comment_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.comment_.Set("", GetArena());
  }
  return released;
}
inline void ImdOutputProto::set_allocated_comment(::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_.comment_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.comment_.IsDefault()) {
    _impl_.comment_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:ImdOutputProto.comment)
}

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

// ImageWriterProto

// optional string filename = 1 [json_name = "filename", (.help) = "filename of output sector image"];
inline bool ImageWriterProto::has_filename() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void ImageWriterProto::clear_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& ImageWriterProto::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageWriterProto.filename)
  return _internal_filename();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ImageWriterProto::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:ImageWriterProto.filename)
}
inline ::std::string* PROTOBUF_NONNULL ImageWriterProto::mutable_filename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:ImageWriterProto.filename)
  return _s;
}
inline const ::std::string& ImageWriterProto::_internal_filename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filename_.Get();
}
inline void ImageWriterProto::_internal_set_filename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ImageWriterProto::_internal_mutable_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.filename_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ImageWriterProto::release_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageWriterProto.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 ImageWriterProto::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:ImageWriterProto.filename)
}

// optional .ImageReaderWriterType type = 10 [default = IMAGETYPE_NOT_SET, json_name = "type", (.help) = "image writer type"];
inline bool ImageWriterProto::has_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void ImageWriterProto::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline ::ImageReaderWriterType ImageWriterProto::type() const {
  // @@protoc_insertion_point(field_get:ImageWriterProto.type)
  return _internal_type();
}
inline void ImageWriterProto::set_type(::ImageReaderWriterType value) {
  _internal_set_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  // @@protoc_insertion_point(field_set:ImageWriterProto.type)
}
inline ::ImageReaderWriterType ImageWriterProto::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::ImageReaderWriterType>(_impl_.type_);
}
inline void ImageWriterProto::_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 ImageWriterProto::has_img() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.img_ != nullptr);
  return value;
}
inline const ::ImgInputOutputProto& ImageWriterProto::_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& ImageWriterProto::img() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageWriterProto.img)
  return _internal_img();
}
inline void ImageWriterProto::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:ImageWriterProto.img)
}
inline ::ImgInputOutputProto* PROTOBUF_NULLABLE ImageWriterProto::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 ImageWriterProto::unsafe_arena_release_img() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageWriterProto.img)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::ImgInputOutputProto* temp = _impl_.img_;
  _impl_.img_ = nullptr;
  return temp;
}
inline ::ImgInputOutputProto* PROTOBUF_NONNULL ImageWriterProto::_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 ImageWriterProto::mutable_img()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::ImgInputOutputProto* _msg = _internal_mutable_img();
  // @@protoc_insertion_point(field_mutable:ImageWriterProto.img)
  return _msg;
}
inline void ImageWriterProto::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 = reinterpret_cast<::google::protobuf::Message*>(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:ImageWriterProto.img)
}

// optional .D64OutputProto d64 = 3 [json_name = "d64"];
inline bool ImageWriterProto::has_d64() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.d64_ != nullptr);
  return value;
}
inline void ImageWriterProto::clear_d64() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.d64_ != nullptr) _impl_.d64_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::D64OutputProto& ImageWriterProto::_internal_d64() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::D64OutputProto* p = _impl_.d64_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::D64OutputProto>(&::D64OutputProto_globals_);
}
inline const ::D64OutputProto& ImageWriterProto::d64() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageWriterProto.d64)
  return _internal_d64();
}
inline void ImageWriterProto::unsafe_arena_set_allocated_d64(
    ::D64OutputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.d64_);
  }
  _impl_.d64_ = reinterpret_cast<::D64OutputProto*>(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:ImageWriterProto.d64)
}
inline ::D64OutputProto* PROTOBUF_NULLABLE ImageWriterProto::release_d64() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::D64OutputProto* 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 ::D64OutputProto* PROTOBUF_NULLABLE ImageWriterProto::unsafe_arena_release_d64() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageWriterProto.d64)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::D64OutputProto* temp = _impl_.d64_;
  _impl_.d64_ = nullptr;
  return temp;
}
inline ::D64OutputProto* PROTOBUF_NONNULL ImageWriterProto::_internal_mutable_d64() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.d64_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::D64OutputProto>(GetArena());
    _impl_.d64_ = reinterpret_cast<::D64OutputProto*>(p);
  }
  return _impl_.d64_;
}
inline ::D64OutputProto* PROTOBUF_NONNULL ImageWriterProto::mutable_d64()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::D64OutputProto* _msg = _internal_mutable_d64();
  // @@protoc_insertion_point(field_mutable:ImageWriterProto.d64)
  return _msg;
}
inline void ImageWriterProto::set_allocated_d64(::D64OutputProto* 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], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }

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

// optional .LDBSOutputProto ldbs = 4 [json_name = "ldbs"];
inline bool ImageWriterProto::has_ldbs() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.ldbs_ != nullptr);
  return value;
}
inline void ImageWriterProto::clear_ldbs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.ldbs_ != nullptr) _impl_.ldbs_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::LDBSOutputProto& ImageWriterProto::_internal_ldbs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::LDBSOutputProto* p = _impl_.ldbs_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::LDBSOutputProto>(&::LDBSOutputProto_globals_);
}
inline const ::LDBSOutputProto& ImageWriterProto::ldbs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageWriterProto.ldbs)
  return _internal_ldbs();
}
inline void ImageWriterProto::unsafe_arena_set_allocated_ldbs(
    ::LDBSOutputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.ldbs_);
  }
  _impl_.ldbs_ = reinterpret_cast<::LDBSOutputProto*>(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:ImageWriterProto.ldbs)
}
inline ::LDBSOutputProto* PROTOBUF_NULLABLE ImageWriterProto::release_ldbs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::LDBSOutputProto* released = _impl_.ldbs_;
  _impl_.ldbs_ = 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 ::LDBSOutputProto* PROTOBUF_NULLABLE ImageWriterProto::unsafe_arena_release_ldbs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageWriterProto.ldbs)

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::LDBSOutputProto* temp = _impl_.ldbs_;
  _impl_.ldbs_ = nullptr;
  return temp;
}
inline ::LDBSOutputProto* PROTOBUF_NONNULL ImageWriterProto::_internal_mutable_ldbs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.ldbs_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::LDBSOutputProto>(GetArena());
    _impl_.ldbs_ = reinterpret_cast<::LDBSOutputProto*>(p);
  }
  return _impl_.ldbs_;
}
inline ::LDBSOutputProto* PROTOBUF_NONNULL ImageWriterProto::mutable_ldbs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::LDBSOutputProto* _msg = _internal_mutable_ldbs();
  // @@protoc_insertion_point(field_mutable:ImageWriterProto.ldbs)
  return _msg;
}
inline void ImageWriterProto::set_allocated_ldbs(::LDBSOutputProto* 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_.ldbs_);
  }

  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_.ldbs_ = reinterpret_cast<::LDBSOutputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageWriterProto.ldbs)
}

// optional .DiskCopyOutputProto diskcopy = 5 [json_name = "diskcopy"];
inline bool ImageWriterProto::has_diskcopy() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.diskcopy_ != nullptr);
  return value;
}
inline void ImageWriterProto::clear_diskcopy() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.diskcopy_ != nullptr) _impl_.diskcopy_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::DiskCopyOutputProto& ImageWriterProto::_internal_diskcopy() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::DiskCopyOutputProto* p = _impl_.diskcopy_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::DiskCopyOutputProto>(&::DiskCopyOutputProto_globals_);
}
inline const ::DiskCopyOutputProto& ImageWriterProto::diskcopy() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageWriterProto.diskcopy)
  return _internal_diskcopy();
}
inline void ImageWriterProto::unsafe_arena_set_allocated_diskcopy(
    ::DiskCopyOutputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.diskcopy_);
  }
  _impl_.diskcopy_ = reinterpret_cast<::DiskCopyOutputProto*>(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:ImageWriterProto.diskcopy)
}
inline ::DiskCopyOutputProto* PROTOBUF_NULLABLE ImageWriterProto::release_diskcopy() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::DiskCopyOutputProto* 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 ::DiskCopyOutputProto* PROTOBUF_NULLABLE ImageWriterProto::unsafe_arena_release_diskcopy() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageWriterProto.diskcopy)

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::DiskCopyOutputProto* temp = _impl_.diskcopy_;
  _impl_.diskcopy_ = nullptr;
  return temp;
}
inline ::DiskCopyOutputProto* PROTOBUF_NONNULL ImageWriterProto::_internal_mutable_diskcopy() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.diskcopy_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::DiskCopyOutputProto>(GetArena());
    _impl_.diskcopy_ = reinterpret_cast<::DiskCopyOutputProto*>(p);
  }
  return _impl_.diskcopy_;
}
inline ::DiskCopyOutputProto* PROTOBUF_NONNULL ImageWriterProto::mutable_diskcopy()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::DiskCopyOutputProto* _msg = _internal_mutable_diskcopy();
  // @@protoc_insertion_point(field_mutable:ImageWriterProto.diskcopy)
  return _msg;
}
inline void ImageWriterProto::set_allocated_diskcopy(::DiskCopyOutputProto* 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], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }

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

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

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::NsiOutputProto* 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 ::NsiOutputProto* PROTOBUF_NULLABLE ImageWriterProto::unsafe_arena_release_nsi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageWriterProto.nsi)

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::NsiOutputProto* temp = _impl_.nsi_;
  _impl_.nsi_ = nullptr;
  return temp;
}
inline ::NsiOutputProto* PROTOBUF_NONNULL ImageWriterProto::_internal_mutable_nsi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.nsi_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::NsiOutputProto>(GetArena());
    _impl_.nsi_ = reinterpret_cast<::NsiOutputProto*>(p);
  }
  return _impl_.nsi_;
}
inline ::NsiOutputProto* PROTOBUF_NONNULL ImageWriterProto::mutable_nsi()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::NsiOutputProto* _msg = _internal_mutable_nsi();
  // @@protoc_insertion_point(field_mutable:ImageWriterProto.nsi)
  return _msg;
}
inline void ImageWriterProto::set_allocated_nsi(::NsiOutputProto* 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], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }

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

// optional .RawOutputProto raw = 7 [json_name = "raw"];
inline bool ImageWriterProto::has_raw() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  PROTOBUF_ASSUME(!value || _impl_.raw_ != nullptr);
  return value;
}
inline void ImageWriterProto::clear_raw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.raw_ != nullptr) _impl_.raw_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::RawOutputProto& ImageWriterProto::_internal_raw() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::RawOutputProto* p = _impl_.raw_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::RawOutputProto>(&::RawOutputProto_globals_);
}
inline const ::RawOutputProto& ImageWriterProto::raw() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageWriterProto.raw)
  return _internal_raw();
}
inline void ImageWriterProto::unsafe_arena_set_allocated_raw(
    ::RawOutputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.raw_);
  }
  _impl_.raw_ = reinterpret_cast<::RawOutputProto*>(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:ImageWriterProto.raw)
}
inline ::RawOutputProto* PROTOBUF_NULLABLE ImageWriterProto::release_raw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::RawOutputProto* released = _impl_.raw_;
  _impl_.raw_ = 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 ::RawOutputProto* PROTOBUF_NULLABLE ImageWriterProto::unsafe_arena_release_raw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageWriterProto.raw)

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::RawOutputProto* temp = _impl_.raw_;
  _impl_.raw_ = nullptr;
  return temp;
}
inline ::RawOutputProto* PROTOBUF_NONNULL ImageWriterProto::_internal_mutable_raw() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.raw_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::RawOutputProto>(GetArena());
    _impl_.raw_ = reinterpret_cast<::RawOutputProto*>(p);
  }
  return _impl_.raw_;
}
inline ::RawOutputProto* PROTOBUF_NONNULL ImageWriterProto::mutable_raw()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::RawOutputProto* _msg = _internal_mutable_raw();
  // @@protoc_insertion_point(field_mutable:ImageWriterProto.raw)
  return _msg;
}
inline void ImageWriterProto::set_allocated_raw(::RawOutputProto* 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_.raw_);
  }

  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_.raw_ = reinterpret_cast<::RawOutputProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:ImageWriterProto.raw)
}

// optional .D88OutputProto d88 = 8 [json_name = "d88"];
inline bool ImageWriterProto::has_d88() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  PROTOBUF_ASSUME(!value || _impl_.d88_ != nullptr);
  return value;
}
inline void ImageWriterProto::clear_d88() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.d88_ != nullptr) _impl_.d88_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::D88OutputProto& ImageWriterProto::_internal_d88() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::D88OutputProto* p = _impl_.d88_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::D88OutputProto>(&::D88OutputProto_globals_);
}
inline const ::D88OutputProto& ImageWriterProto::d88() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageWriterProto.d88)
  return _internal_d88();
}
inline void ImageWriterProto::unsafe_arena_set_allocated_d88(
    ::D88OutputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.d88_);
  }
  _impl_.d88_ = reinterpret_cast<::D88OutputProto*>(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:ImageWriterProto.d88)
}
inline ::D88OutputProto* PROTOBUF_NULLABLE ImageWriterProto::release_d88() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::D88OutputProto* 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 ::D88OutputProto* PROTOBUF_NULLABLE ImageWriterProto::unsafe_arena_release_d88() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageWriterProto.d88)

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::D88OutputProto* temp = _impl_.d88_;
  _impl_.d88_ = nullptr;
  return temp;
}
inline ::D88OutputProto* PROTOBUF_NONNULL ImageWriterProto::_internal_mutable_d88() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.d88_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::D88OutputProto>(GetArena());
    _impl_.d88_ = reinterpret_cast<::D88OutputProto*>(p);
  }
  return _impl_.d88_;
}
inline ::D88OutputProto* PROTOBUF_NONNULL ImageWriterProto::mutable_d88()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::D88OutputProto* _msg = _internal_mutable_d88();
  // @@protoc_insertion_point(field_mutable:ImageWriterProto.d88)
  return _msg;
}
inline void ImageWriterProto::set_allocated_d88(::D88OutputProto* 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], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }

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

// optional .ImdOutputProto imd = 9 [json_name = "imd"];
inline bool ImageWriterProto::has_imd() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.imd_ != nullptr);
  return value;
}
inline void ImageWriterProto::clear_imd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.imd_ != nullptr) _impl_.imd_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline const ::ImdOutputProto& ImageWriterProto::_internal_imd() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::ImdOutputProto* p = _impl_.imd_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::ImdOutputProto>(&::ImdOutputProto_globals_);
}
inline const ::ImdOutputProto& ImageWriterProto::imd() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ImageWriterProto.imd)
  return _internal_imd();
}
inline void ImageWriterProto::unsafe_arena_set_allocated_imd(
    ::ImdOutputProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.imd_);
  }
  _impl_.imd_ = reinterpret_cast<::ImdOutputProto*>(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:ImageWriterProto.imd)
}
inline ::ImdOutputProto* PROTOBUF_NULLABLE ImageWriterProto::release_imd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::ImdOutputProto* 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 ::ImdOutputProto* PROTOBUF_NULLABLE ImageWriterProto::unsafe_arena_release_imd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ImageWriterProto.imd)

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::ImdOutputProto* temp = _impl_.imd_;
  _impl_.imd_ = nullptr;
  return temp;
}
inline ::ImdOutputProto* PROTOBUF_NONNULL ImageWriterProto::_internal_mutable_imd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.imd_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::ImdOutputProto>(GetArena());
    _impl_.imd_ = reinterpret_cast<::ImdOutputProto*>(p);
  }
  return _impl_.imd_;
}
inline ::ImdOutputProto* PROTOBUF_NONNULL ImageWriterProto::mutable_imd()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::ImdOutputProto* _msg = _internal_mutable_imd();
  // @@protoc_insertion_point(field_mutable:ImageWriterProto.imd)
  return _msg;
}
inline void ImageWriterProto::set_allocated_imd(::ImdOutputProto* 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], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }

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

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

// @@protoc_insertion_point(namespace_scope)


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::LDBSOutputProto_DataRate> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::LDBSOutputProto_DataRate>() {
  return ::LDBSOutputProto_DataRate_descriptor();
}
template <>
struct is_proto_enum<::LDBSOutputProto_RecordingMode> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::LDBSOutputProto_RecordingMode>() {
  return ::LDBSOutputProto_RecordingMode_descriptor();
}
template <>
struct is_proto_enum<::ImdOutputProto_DataRate> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::ImdOutputProto_DataRate>() {
  return ::ImdOutputProto_DataRate_descriptor();
}
template <>
struct is_proto_enum<::ImdOutputProto_RecordingMode> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::ImdOutputProto_RecordingMode>() {
  return ::ImdOutputProto_RecordingMode_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

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

#endif  // lib_2fimagewriter_2fimagewriter_2eproto_2epb_2eh
