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

#ifndef lib_2fvfs_2fvfs_2eproto_2epb_2eh
#define lib_2fvfs_2fvfs_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/config/common.pb.h"
// @@protoc_insertion_point(includes)

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

#define PROTOBUF_INTERNAL_EXPORT_lib_2fvfs_2fvfs_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_lib_2fvfs_2fvfs_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_lib_2fvfs_2fvfs_2eproto;
}  // extern "C"
enum AcornDfsProto_Flavour : int;
extern const uint32_t AcornDfsProto_Flavour_internal_data_[];
enum FilesystemProto_FilesystemType : int;
extern const uint32_t FilesystemProto_FilesystemType_internal_data_[];
class AcornDfsProto;
struct AcornDfsProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern AcornDfsProtoGlobalsTypeInternal AcornDfsProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull AcornDfsProto_class_data_;
#else
extern const AcornDfsProtoGlobalsTypeInternal AcornDfsProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class AmigaFfsProto;
struct AmigaFfsProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern AmigaFfsProtoGlobalsTypeInternal AmigaFfsProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull AmigaFfsProto_class_data_;
#else
extern const AmigaFfsProtoGlobalsTypeInternal AmigaFfsProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class AppledosProto;
struct AppledosProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern AppledosProtoGlobalsTypeInternal AppledosProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull AppledosProto_class_data_;
#else
extern const AppledosProtoGlobalsTypeInternal AppledosProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Brother120FsProto;
struct Brother120FsProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern Brother120FsProtoGlobalsTypeInternal Brother120FsProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull Brother120FsProto_class_data_;
#else
extern const Brother120FsProtoGlobalsTypeInternal Brother120FsProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class CbmfsProto;
struct CbmfsProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern CbmfsProtoGlobalsTypeInternal CbmfsProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull CbmfsProto_class_data_;
#else
extern const CbmfsProtoGlobalsTypeInternal CbmfsProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class CpmFsProto;
struct CpmFsProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern CpmFsProtoGlobalsTypeInternal CpmFsProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull CpmFsProto_class_data_;
#else
extern const CpmFsProtoGlobalsTypeInternal CpmFsProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class CpmFsProto_Location;
struct CpmFsProto_LocationGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern CpmFsProto_LocationGlobalsTypeInternal CpmFsProto_Location_globals_;
extern const ::google::protobuf::internal::ClassDataFull CpmFsProto_Location_class_data_;
#else
extern const CpmFsProto_LocationGlobalsTypeInternal CpmFsProto_Location_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class CpmFsProto_Padding;
struct CpmFsProto_PaddingGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern CpmFsProto_PaddingGlobalsTypeInternal CpmFsProto_Padding_globals_;
extern const ::google::protobuf::internal::ClassDataFull CpmFsProto_Padding_class_data_;
#else
extern const CpmFsProto_PaddingGlobalsTypeInternal CpmFsProto_Padding_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class FatFsProto;
struct FatFsProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern FatFsProtoGlobalsTypeInternal FatFsProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull FatFsProto_class_data_;
#else
extern const FatFsProtoGlobalsTypeInternal FatFsProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class FilesystemProto;
struct FilesystemProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern FilesystemProtoGlobalsTypeInternal FilesystemProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull FilesystemProto_class_data_;
#else
extern const FilesystemProtoGlobalsTypeInternal FilesystemProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class LifProto;
struct LifProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern LifProtoGlobalsTypeInternal LifProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull LifProto_class_data_;
#else
extern const LifProtoGlobalsTypeInternal LifProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class MacHfsProto;
struct MacHfsProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern MacHfsProtoGlobalsTypeInternal MacHfsProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull MacHfsProto_class_data_;
#else
extern const MacHfsProtoGlobalsTypeInternal MacHfsProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class MicrodosProto;
struct MicrodosProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern MicrodosProtoGlobalsTypeInternal MicrodosProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull MicrodosProto_class_data_;
#else
extern const MicrodosProtoGlobalsTypeInternal MicrodosProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class PhileProto;
struct PhileProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern PhileProtoGlobalsTypeInternal PhileProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull PhileProto_class_data_;
#else
extern const PhileProtoGlobalsTypeInternal PhileProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ProdosProto;
struct ProdosProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ProdosProtoGlobalsTypeInternal ProdosProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull ProdosProto_class_data_;
#else
extern const ProdosProtoGlobalsTypeInternal ProdosProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class RolandFsProto;
struct RolandFsProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern RolandFsProtoGlobalsTypeInternal RolandFsProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull RolandFsProto_class_data_;
#else
extern const RolandFsProtoGlobalsTypeInternal RolandFsProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Smaky6FsProto;
struct Smaky6FsProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern Smaky6FsProtoGlobalsTypeInternal Smaky6FsProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull Smaky6FsProto_class_data_;
#else
extern const Smaky6FsProtoGlobalsTypeInternal Smaky6FsProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ZDosProto;
struct ZDosProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ZDosProtoGlobalsTypeInternal ZDosProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull ZDosProto_class_data_;
#else
extern const ZDosProtoGlobalsTypeInternal ZDosProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ZDosProto_Location;
struct ZDosProto_LocationGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ZDosProto_LocationGlobalsTypeInternal ZDosProto_Location_globals_;
extern const ::google::protobuf::internal::ClassDataFull ZDosProto_Location_class_data_;
#else
extern const ZDosProto_LocationGlobalsTypeInternal ZDosProto_Location_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::AcornDfsProto_Flavour_internal_data_>
    internal::EnumTraitsImpl::value<::AcornDfsProto_Flavour>;
template <>
internal::EnumTraitsT<::FilesystemProto_FilesystemType_internal_data_>
    internal::EnumTraitsImpl::value<::FilesystemProto_FilesystemType>;
}  // namespace protobuf
}  // namespace google

enum AcornDfsProto_Flavour : int {
  AcornDfsProto_Flavour_UNDEFINED = 0,
  AcornDfsProto_Flavour_ACORN_DFS = 1,
};

extern const uint32_t AcornDfsProto_Flavour_internal_data_[];
inline constexpr AcornDfsProto_Flavour AcornDfsProto_Flavour_Flavour_MIN =
    static_cast<AcornDfsProto_Flavour>(0);
inline constexpr AcornDfsProto_Flavour AcornDfsProto_Flavour_Flavour_MAX =
    static_cast<AcornDfsProto_Flavour>(1);
[[nodiscard]] inline bool AcornDfsProto_Flavour_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int AcornDfsProto_Flavour_Flavour_ARRAYSIZE = 1 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
AcornDfsProto_Flavour_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(AcornDfsProto_Flavour) {
  return AcornDfsProto_Flavour_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& AcornDfsProto_Flavour_Name(T value) {
  static_assert(::std::is_same<T, AcornDfsProto_Flavour>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Flavour_Name().");
  return AcornDfsProto_Flavour_Name(static_cast<AcornDfsProto_Flavour>(value));
}
template <>
[[nodiscard]] inline const ::std::string& AcornDfsProto_Flavour_Name(AcornDfsProto_Flavour value) {
  return ::google::protobuf::internal::NameOfDenseEnum<AcornDfsProto_Flavour_descriptor, 0, 1>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool AcornDfsProto_Flavour_Parse(
    ::absl::string_view name, AcornDfsProto_Flavour* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<AcornDfsProto_Flavour>(AcornDfsProto_Flavour_descriptor(), name,
                                           value);
}
enum FilesystemProto_FilesystemType : int {
  FilesystemProto_FilesystemType_NOT_SET = 0,
  FilesystemProto_FilesystemType_ACORNDFS = 1,
  FilesystemProto_FilesystemType_BROTHER120 = 2,
  FilesystemProto_FilesystemType_FATFS = 3,
  FilesystemProto_FilesystemType_CPMFS = 4,
  FilesystemProto_FilesystemType_AMIGAFFS = 5,
  FilesystemProto_FilesystemType_MACHFS = 6,
  FilesystemProto_FilesystemType_CBMFS = 7,
  FilesystemProto_FilesystemType_PRODOS = 8,
  FilesystemProto_FilesystemType_SMAKY6 = 9,
  FilesystemProto_FilesystemType_APPLEDOS = 10,
  FilesystemProto_FilesystemType_PHILE = 11,
  FilesystemProto_FilesystemType_LIF = 12,
  FilesystemProto_FilesystemType_MICRODOS = 13,
  FilesystemProto_FilesystemType_ZDOS = 14,
  FilesystemProto_FilesystemType_ROLAND = 15,
};

extern const uint32_t FilesystemProto_FilesystemType_internal_data_[];
inline constexpr FilesystemProto_FilesystemType FilesystemProto_FilesystemType_FilesystemType_MIN =
    static_cast<FilesystemProto_FilesystemType>(0);
inline constexpr FilesystemProto_FilesystemType FilesystemProto_FilesystemType_FilesystemType_MAX =
    static_cast<FilesystemProto_FilesystemType>(15);
[[nodiscard]] inline bool FilesystemProto_FilesystemType_IsValid(int value) {
  return 0 <= value && value <= 15;
}
inline constexpr int FilesystemProto_FilesystemType_FilesystemType_ARRAYSIZE = 15 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
FilesystemProto_FilesystemType_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(FilesystemProto_FilesystemType) {
  return FilesystemProto_FilesystemType_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& FilesystemProto_FilesystemType_Name(T value) {
  static_assert(::std::is_same<T, FilesystemProto_FilesystemType>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to FilesystemType_Name().");
  return FilesystemProto_FilesystemType_Name(static_cast<FilesystemProto_FilesystemType>(value));
}
template <>
[[nodiscard]] inline const ::std::string& FilesystemProto_FilesystemType_Name(FilesystemProto_FilesystemType value) {
  return ::google::protobuf::internal::NameOfDenseEnum<FilesystemProto_FilesystemType_descriptor, 0, 15>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool FilesystemProto_FilesystemType_Parse(
    ::absl::string_view name, FilesystemProto_FilesystemType* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<FilesystemProto_FilesystemType>(FilesystemProto_FilesystemType_descriptor(), name,
                                           value);
}
using ::google::protobuf::internal::generated_enum::AbslParseFlag;
using ::google::protobuf::internal::generated_enum::AbslUnparseFlag;

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


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

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

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

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

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

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

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

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

  explicit ZDosProto_Location(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ZDosProto_Location(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ZDosProto_Location& from);
  ZDosProto_Location(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ZDosProto_Location&& from) noexcept
      : ZDosProto_Location(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 {
    kTrackFieldNumber = 1,
    kSectorFieldNumber = 3,
  };
  // optional uint32 track = 1 [json_name = "track", (.help) = "track number"];
  [[nodiscard]] bool has_track() const;
  void clear_track() ;
  [[nodiscard]] ::uint32_t track() const;
  void set_track(::uint32_t value);

  private:
  ::uint32_t _internal_track() const;
  void _internal_set_track(::uint32_t value);

  public:
  // optional uint32 sector = 3 [json_name = "sector", (.help) = "sector ID"];
  [[nodiscard]] bool has_sector() const;
  void clear_sector() ;
  [[nodiscard]] ::uint32_t sector() const;
  void set_sector(::uint32_t value);

  private:
  ::uint32_t _internal_sector() const;
  void _internal_set_sector(::uint32_t value);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  explicit RolandFsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  RolandFsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RolandFsProto& from);
  RolandFsProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RolandFsProto&& from) noexcept
      : RolandFsProto(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 {
    kDirectoryTrackFieldNumber = 1,
    kBlockSizeFieldNumber = 2,
    kDirectoryEntriesFieldNumber = 3,
  };
  // optional uint32 directory_track = 1 [default = 39, json_name = "directoryTrack", (.help) = "position of the directory"];
  [[nodiscard]] bool has_directory_track() const;
  void clear_directory_track() ;
  [[nodiscard]] ::uint32_t directory_track() const;
  void set_directory_track(::uint32_t value);

  private:
  ::uint32_t _internal_directory_track() const;
  void _internal_set_directory_track(::uint32_t value);

  public:
  // optional uint32 block_size = 2 [default = 3072, json_name = "blockSize", (.help) = "filesystem block size"];
  [[nodiscard]] bool has_block_size() const;
  void clear_block_size() ;
  [[nodiscard]] ::uint32_t block_size() const;
  void set_block_size(::uint32_t value);

  private:
  ::uint32_t _internal_block_size() const;
  void _internal_set_block_size(::uint32_t value);

  public:
  // optional uint32 directory_entries = 3 [default = 79, json_name = "directoryEntries", (.help) = "number of directory entries"];
  [[nodiscard]] bool has_directory_entries() const;
  void clear_directory_entries() ;
  [[nodiscard]] ::uint32_t directory_entries() const;
  void set_directory_entries(::uint32_t value);

  private:
  ::uint32_t _internal_directory_entries() const;
  void _internal_set_directory_entries(::uint32_t value);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  explicit PhileProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  PhileProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PhileProto& from);
  PhileProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PhileProto&& from) noexcept
      : PhileProto(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 {
    kBlockSizeFieldNumber = 1,
  };
  // optional uint32 block_size = 1 [default = 1024, json_name = "blockSize", (.help) = "Phile filesystem block size"];
  [[nodiscard]] bool has_block_size() const;
  void clear_block_size() ;
  [[nodiscard]] ::uint32_t block_size() const;
  void set_block_size(::uint32_t value);

  private:
  ::uint32_t _internal_block_size() const;
  void _internal_set_block_size(::uint32_t value);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  explicit LifProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  LifProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LifProto& from);
  LifProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, LifProto&& from) noexcept
      : LifProto(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 {
    kBlockSizeFieldNumber = 1,
  };
  // optional uint32 block_size = 1 [default = 256, json_name = "blockSize", (.help) = "LIF filesystem block size"];
  [[nodiscard]] bool has_block_size() const;
  void clear_block_size() ;
  [[nodiscard]] ::uint32_t block_size() const;
  void set_block_size(::uint32_t value);

  private:
  ::uint32_t _internal_block_size() const;
  void _internal_set_block_size(::uint32_t value);

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

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

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

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

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

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

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

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

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

  explicit FatFsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  FatFsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FatFsProto& from);
  FatFsProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, FatFsProto&& from) noexcept
      : FatFsProto(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 {
    kClusterSizeFieldNumber = 1,
    kRootDirectoryEntriesFieldNumber = 2,
  };
  // optional uint32 cluster_size = 1 [default = 0, json_name = "clusterSize", (.help) = "cluster size (for new filesystems); 0 to select automatically"];
  [[nodiscard]] bool has_cluster_size() const;
  void clear_cluster_size() ;
  [[nodiscard]] ::uint32_t cluster_size() const;
  void set_cluster_size(::uint32_t value);

  private:
  ::uint32_t _internal_cluster_size() const;
  void _internal_set_cluster_size(::uint32_t value);

  public:
  // optional uint32 root_directory_entries = 2 [default = 0, json_name = "rootDirectoryEntries", (.help) = "number of entries in the root directory (for new filesystems); 0 to select automatically"];
  [[nodiscard]] bool has_root_directory_entries() const;
  void clear_root_directory_entries() ;
  [[nodiscard]] ::uint32_t root_directory_entries() const;
  void set_root_directory_entries(::uint32_t value);

  private:
  ::uint32_t _internal_root_directory_entries() const;
  void _internal_set_root_directory_entries(::uint32_t value);

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

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

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

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

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

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

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

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

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

  explicit CpmFsProto_Padding(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  CpmFsProto_Padding(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const CpmFsProto_Padding& from);
  CpmFsProto_Padding(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, CpmFsProto_Padding&& from) noexcept
      : CpmFsProto_Padding(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 {
    kAmountFieldNumber = 1,
    kEveryFieldNumber = 2,
  };
  // optional uint32 amount = 1 [json_name = "amount", (.help) = "number of sectors of padding to insert"];
  [[nodiscard]] bool has_amount() const;
  void clear_amount() ;
  [[nodiscard]] ::uint32_t amount() const;
  void set_amount(::uint32_t value);

  private:
  ::uint32_t _internal_amount() const;
  void _internal_set_amount(::uint32_t value);

  public:
  // optional uint32 every = 2 [json_name = "every", (.help) = "insert padding after this many sectors"];
  [[nodiscard]] bool has_every() const;
  void clear_every() ;
  [[nodiscard]] ::uint32_t every() const;
  void set_every(::uint32_t value);

  private:
  ::uint32_t _internal_every() const;
  void _internal_set_every(::uint32_t value);

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

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

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

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

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

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

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

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

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

  explicit CpmFsProto_Location(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  CpmFsProto_Location(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const CpmFsProto_Location& from);
  CpmFsProto_Location(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, CpmFsProto_Location&& from) noexcept
      : CpmFsProto_Location(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 {
    kTrackFieldNumber = 1,
    kSideFieldNumber = 2,
    kSectorFieldNumber = 3,
  };
  // optional uint32 track = 1 [json_name = "track", (.help) = "track number"];
  [[nodiscard]] bool has_track() const;
  void clear_track() ;
  [[nodiscard]] ::uint32_t track() const;
  void set_track(::uint32_t value);

  private:
  ::uint32_t _internal_track() const;
  void _internal_set_track(::uint32_t value);

  public:
  // optional uint32 side = 2 [json_name = "side", (.help) = "side number"];
  [[nodiscard]] bool has_side() const;
  void clear_side() ;
  [[nodiscard]] ::uint32_t side() const;
  void set_side(::uint32_t value);

  private:
  ::uint32_t _internal_side() const;
  void _internal_set_side(::uint32_t value);

  public:
  // optional uint32 sector = 3 [json_name = "sector", (.help) = "sector ID"];
  [[nodiscard]] bool has_sector() const;
  void clear_sector() ;
  [[nodiscard]] ::uint32_t sector() const;
  void set_sector(::uint32_t value);

  private:
  ::uint32_t _internal_sector() const;
  void _internal_set_sector(::uint32_t value);

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

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

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

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

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

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

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

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

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

  explicit CbmfsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  CbmfsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const CbmfsProto& from);
  CbmfsProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, CbmfsProto&& from) noexcept
      : CbmfsProto(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 {
    kDirectoryTrackFieldNumber = 1,
  };
  // optional uint32 directory_track = 1 [default = 17, json_name = "directoryTrack", (.help) = "which track the directory is on (zero-based numbering)"];
  [[nodiscard]] bool has_directory_track() const;
  void clear_directory_track() ;
  [[nodiscard]] ::uint32_t directory_track() const;
  void set_directory_track(::uint32_t value);

  private:
  ::uint32_t _internal_directory_track() const;
  void _internal_set_directory_track(::uint32_t value);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  explicit AppledosProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AppledosProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AppledosProto& from);
  AppledosProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AppledosProto&& from) noexcept
      : AppledosProto(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 {
    kFilesystemOffsetSectorsFieldNumber = 1,
  };
  // optional uint32 filesystem_offset_sectors = 1 [default = 0, json_name = "filesystemOffsetSectors", (.help) = "offset the entire offset up the disk this many sectors"];
  [[nodiscard]] bool has_filesystem_offset_sectors() const;
  void clear_filesystem_offset_sectors() ;
  [[nodiscard]] ::uint32_t filesystem_offset_sectors() const;
  void set_filesystem_offset_sectors(::uint32_t value);

  private:
  ::uint32_t _internal_filesystem_offset_sectors() const;
  void _internal_set_filesystem_offset_sectors(::uint32_t value);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  explicit AcornDfsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AcornDfsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AcornDfsProto& from);
  AcornDfsProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AcornDfsProto&& from) noexcept
      : AcornDfsProto(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 Flavour = AcornDfsProto_Flavour;
  static constexpr Flavour UNDEFINED = AcornDfsProto_Flavour_UNDEFINED;
  static constexpr Flavour ACORN_DFS = AcornDfsProto_Flavour_ACORN_DFS;
  [[nodiscard]] static inline bool Flavour_IsValid(int value) {
    return AcornDfsProto_Flavour_IsValid(value);
  }
  static constexpr Flavour Flavour_MIN = AcornDfsProto_Flavour_Flavour_MIN;
  static constexpr Flavour Flavour_MAX = AcornDfsProto_Flavour_Flavour_MAX;
  static constexpr int Flavour_ARRAYSIZE = AcornDfsProto_Flavour_Flavour_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Flavour_descriptor() {
    return AcornDfsProto_Flavour_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Flavour_Name(T value) {
    return AcornDfsProto_Flavour_Name(value);
  }
  [[nodiscard]] static inline bool Flavour_Parse(
      ::absl::string_view name, Flavour* PROTOBUF_NONNULL value) {
    return AcornDfsProto_Flavour_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kFlavourFieldNumber = 1,
  };
  // optional .AcornDfsProto.Flavour flavour = 1 [default = ACORN_DFS, json_name = "flavour", (.help) = "which flavour of DFS to implement"];
  [[nodiscard]] bool has_flavour() const;
  void clear_flavour() ;
  [[nodiscard]] ::AcornDfsProto_Flavour flavour() const;
  void set_flavour(::AcornDfsProto_Flavour value);

  private:
  ::AcornDfsProto_Flavour _internal_flavour() const;
  void _internal_set_flavour(::AcornDfsProto_Flavour value);

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

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

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

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

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

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

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

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

  explicit ZDosProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ZDosProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ZDosProto& from);
  ZDosProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ZDosProto&& from) noexcept
      : ZDosProto(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 Location = ZDosProto_Location;

  // accessors -------------------------------------------------------
  enum : int {
    kFilesystemStartFieldNumber = 1,
  };
  // optional .ZDosProto.Location filesystem_start = 1 [json_name = "filesystemStart", (.help) = "position of the filesystem superblock"];
  [[nodiscard]] bool has_filesystem_start() const;
  void clear_filesystem_start() ;
  [[nodiscard]] const ::ZDosProto_Location& filesystem_start() const;
  [[nodiscard]] ::ZDosProto_Location* PROTOBUF_NULLABLE release_filesystem_start();
  ::ZDosProto_Location* PROTOBUF_NONNULL mutable_filesystem_start();
  void set_allocated_filesystem_start(::ZDosProto_Location* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_filesystem_start(::ZDosProto_Location* PROTOBUF_NULLABLE value);
  ::ZDosProto_Location* PROTOBUF_NULLABLE unsafe_arena_release_filesystem_start();

  private:
  const ::ZDosProto_Location& _internal_filesystem_start() const;
  ::ZDosProto_Location* PROTOBUF_NONNULL _internal_mutable_filesystem_start();

  public:
  // @@protoc_insertion_point(class_scope:ZDosProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          1, 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 ZDosProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::ZDosProto_Location* PROTOBUF_NULLABLE filesystem_start_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fvfs_2fvfs_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  explicit CpmFsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  CpmFsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const CpmFsProto& from);
  CpmFsProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, CpmFsProto&& from) noexcept
      : CpmFsProto(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 Location = CpmFsProto_Location;
  using Padding = CpmFsProto_Padding;

  // accessors -------------------------------------------------------
  enum : int {
    kFilesystemStartFieldNumber = 1,
    kPaddingFieldNumber = 4,
    kBlockSizeFieldNumber = 2,
    kDirEntriesFieldNumber = 3,
  };
  // optional .CpmFsProto.Location filesystem_start = 1 [json_name = "filesystemStart", (.help) = "position of the start of the filesystem"];
  [[nodiscard]] bool has_filesystem_start() const;
  void clear_filesystem_start() ;
  [[nodiscard]] const ::CpmFsProto_Location& filesystem_start() const;
  [[nodiscard]] ::CpmFsProto_Location* PROTOBUF_NULLABLE release_filesystem_start();
  ::CpmFsProto_Location* PROTOBUF_NONNULL mutable_filesystem_start();
  void set_allocated_filesystem_start(::CpmFsProto_Location* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_filesystem_start(::CpmFsProto_Location* PROTOBUF_NULLABLE value);
  ::CpmFsProto_Location* PROTOBUF_NULLABLE unsafe_arena_release_filesystem_start();

  private:
  const ::CpmFsProto_Location& _internal_filesystem_start() const;
  ::CpmFsProto_Location* PROTOBUF_NONNULL _internal_mutable_filesystem_start();

  public:
  // optional .CpmFsProto.Padding padding = 4 [json_name = "padding", (.help) = "wasted sectors not considered part of the filesystem"];
  [[nodiscard]] bool has_padding() const;
  void clear_padding() ;
  [[nodiscard]] const ::CpmFsProto_Padding& padding() const;
  [[nodiscard]] ::CpmFsProto_Padding* PROTOBUF_NULLABLE release_padding();
  ::CpmFsProto_Padding* PROTOBUF_NONNULL mutable_padding();
  void set_allocated_padding(::CpmFsProto_Padding* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_padding(::CpmFsProto_Padding* PROTOBUF_NULLABLE value);
  ::CpmFsProto_Padding* PROTOBUF_NULLABLE unsafe_arena_release_padding();

  private:
  const ::CpmFsProto_Padding& _internal_padding() const;
  ::CpmFsProto_Padding* PROTOBUF_NONNULL _internal_mutable_padding();

  public:
  // optional int32 block_size = 2 [json_name = "blockSize", (.help) = "allocation block size"];
  [[nodiscard]] bool has_block_size() const;
  void clear_block_size() ;
  [[nodiscard]] ::int32_t block_size() const;
  void set_block_size(::int32_t value);

  private:
  ::int32_t _internal_block_size() const;
  void _internal_set_block_size(::int32_t value);

  public:
  // optional int32 dir_entries = 3 [json_name = "dirEntries", (.help) = "number of entries in the directory"];
  [[nodiscard]] bool has_dir_entries() const;
  void clear_dir_entries() ;
  [[nodiscard]] ::int32_t dir_entries() const;
  void set_dir_entries(::int32_t value);

  private:
  ::int32_t _internal_dir_entries() const;
  void _internal_set_dir_entries(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:CpmFsProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 4,
                          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 CpmFsProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::CpmFsProto_Location* PROTOBUF_NULLABLE filesystem_start_;
    ::CpmFsProto_Padding* PROTOBUF_NULLABLE padding_;
    ::int32_t block_size_;
    ::int32_t dir_entries_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fvfs_2fvfs_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  explicit FilesystemProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  FilesystemProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FilesystemProto& from);
  FilesystemProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, FilesystemProto&& from) noexcept
      : FilesystemProto(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 FilesystemType = FilesystemProto_FilesystemType;
  static constexpr FilesystemType NOT_SET = FilesystemProto_FilesystemType_NOT_SET;
  static constexpr FilesystemType ACORNDFS = FilesystemProto_FilesystemType_ACORNDFS;
  static constexpr FilesystemType BROTHER120 = FilesystemProto_FilesystemType_BROTHER120;
  static constexpr FilesystemType FATFS = FilesystemProto_FilesystemType_FATFS;
  static constexpr FilesystemType CPMFS = FilesystemProto_FilesystemType_CPMFS;
  static constexpr FilesystemType AMIGAFFS = FilesystemProto_FilesystemType_AMIGAFFS;
  static constexpr FilesystemType MACHFS = FilesystemProto_FilesystemType_MACHFS;
  static constexpr FilesystemType CBMFS = FilesystemProto_FilesystemType_CBMFS;
  static constexpr FilesystemType PRODOS = FilesystemProto_FilesystemType_PRODOS;
  static constexpr FilesystemType SMAKY6 = FilesystemProto_FilesystemType_SMAKY6;
  static constexpr FilesystemType APPLEDOS = FilesystemProto_FilesystemType_APPLEDOS;
  static constexpr FilesystemType PHILE = FilesystemProto_FilesystemType_PHILE;
  static constexpr FilesystemType LIF = FilesystemProto_FilesystemType_LIF;
  static constexpr FilesystemType MICRODOS = FilesystemProto_FilesystemType_MICRODOS;
  static constexpr FilesystemType ZDOS = FilesystemProto_FilesystemType_ZDOS;
  static constexpr FilesystemType ROLAND = FilesystemProto_FilesystemType_ROLAND;
  [[nodiscard]] static inline bool FilesystemType_IsValid(int value) {
    return FilesystemProto_FilesystemType_IsValid(value);
  }
  static constexpr FilesystemType FilesystemType_MIN = FilesystemProto_FilesystemType_FilesystemType_MIN;
  static constexpr FilesystemType FilesystemType_MAX = FilesystemProto_FilesystemType_FilesystemType_MAX;
  static constexpr int FilesystemType_ARRAYSIZE = FilesystemProto_FilesystemType_FilesystemType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL FilesystemType_descriptor() {
    return FilesystemProto_FilesystemType_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& FilesystemType_Name(T value) {
    return FilesystemProto_FilesystemType_Name(value);
  }
  [[nodiscard]] static inline bool FilesystemType_Parse(
      ::absl::string_view name, FilesystemType* PROTOBUF_NONNULL value) {
    return FilesystemProto_FilesystemType_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kAcorndfsFieldNumber = 1,
    kBrother120FieldNumber = 2,
    kFatfsFieldNumber = 3,
    kCpmfsFieldNumber = 4,
    kAmigaffsFieldNumber = 5,
    kMachfsFieldNumber = 6,
    kCbmfsFieldNumber = 7,
    kProdosFieldNumber = 8,
    kSmaky6FieldNumber = 11,
    kAppledosFieldNumber = 12,
    kPhileFieldNumber = 13,
    kLifFieldNumber = 14,
    kMicrodosFieldNumber = 15,
    kZdosFieldNumber = 16,
    kRolandFieldNumber = 17,
    kTypeFieldNumber = 10,
  };
  // optional .AcornDfsProto acorndfs = 1 [json_name = "acorndfs"];
  [[nodiscard]] bool has_acorndfs() const;
  void clear_acorndfs() ;
  [[nodiscard]] const ::AcornDfsProto& acorndfs() const;
  [[nodiscard]] ::AcornDfsProto* PROTOBUF_NULLABLE release_acorndfs();
  ::AcornDfsProto* PROTOBUF_NONNULL mutable_acorndfs();
  void set_allocated_acorndfs(::AcornDfsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_acorndfs(::AcornDfsProto* PROTOBUF_NULLABLE value);
  ::AcornDfsProto* PROTOBUF_NULLABLE unsafe_arena_release_acorndfs();

  private:
  const ::AcornDfsProto& _internal_acorndfs() const;
  ::AcornDfsProto* PROTOBUF_NONNULL _internal_mutable_acorndfs();

  public:
  // optional .Brother120FsProto brother120 = 2 [json_name = "brother120"];
  [[nodiscard]] bool has_brother120() const;
  void clear_brother120() ;
  [[nodiscard]] const ::Brother120FsProto& brother120() const;
  [[nodiscard]] ::Brother120FsProto* PROTOBUF_NULLABLE release_brother120();
  ::Brother120FsProto* PROTOBUF_NONNULL mutable_brother120();
  void set_allocated_brother120(::Brother120FsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_brother120(::Brother120FsProto* PROTOBUF_NULLABLE value);
  ::Brother120FsProto* PROTOBUF_NULLABLE unsafe_arena_release_brother120();

  private:
  const ::Brother120FsProto& _internal_brother120() const;
  ::Brother120FsProto* PROTOBUF_NONNULL _internal_mutable_brother120();

  public:
  // optional .FatFsProto fatfs = 3 [json_name = "fatfs"];
  [[nodiscard]] bool has_fatfs() const;
  void clear_fatfs() ;
  [[nodiscard]] const ::FatFsProto& fatfs() const;
  [[nodiscard]] ::FatFsProto* PROTOBUF_NULLABLE release_fatfs();
  ::FatFsProto* PROTOBUF_NONNULL mutable_fatfs();
  void set_allocated_fatfs(::FatFsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_fatfs(::FatFsProto* PROTOBUF_NULLABLE value);
  ::FatFsProto* PROTOBUF_NULLABLE unsafe_arena_release_fatfs();

  private:
  const ::FatFsProto& _internal_fatfs() const;
  ::FatFsProto* PROTOBUF_NONNULL _internal_mutable_fatfs();

  public:
  // optional .CpmFsProto cpmfs = 4 [json_name = "cpmfs"];
  [[nodiscard]] bool has_cpmfs() const;
  void clear_cpmfs() ;
  [[nodiscard]] const ::CpmFsProto& cpmfs() const;
  [[nodiscard]] ::CpmFsProto* PROTOBUF_NULLABLE release_cpmfs();
  ::CpmFsProto* PROTOBUF_NONNULL mutable_cpmfs();
  void set_allocated_cpmfs(::CpmFsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_cpmfs(::CpmFsProto* PROTOBUF_NULLABLE value);
  ::CpmFsProto* PROTOBUF_NULLABLE unsafe_arena_release_cpmfs();

  private:
  const ::CpmFsProto& _internal_cpmfs() const;
  ::CpmFsProto* PROTOBUF_NONNULL _internal_mutable_cpmfs();

  public:
  // optional .AmigaFfsProto amigaffs = 5 [json_name = "amigaffs"];
  [[nodiscard]] bool has_amigaffs() const;
  void clear_amigaffs() ;
  [[nodiscard]] const ::AmigaFfsProto& amigaffs() const;
  [[nodiscard]] ::AmigaFfsProto* PROTOBUF_NULLABLE release_amigaffs();
  ::AmigaFfsProto* PROTOBUF_NONNULL mutable_amigaffs();
  void set_allocated_amigaffs(::AmigaFfsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_amigaffs(::AmigaFfsProto* PROTOBUF_NULLABLE value);
  ::AmigaFfsProto* PROTOBUF_NULLABLE unsafe_arena_release_amigaffs();

  private:
  const ::AmigaFfsProto& _internal_amigaffs() const;
  ::AmigaFfsProto* PROTOBUF_NONNULL _internal_mutable_amigaffs();

  public:
  // optional .MacHfsProto machfs = 6 [json_name = "machfs"];
  [[nodiscard]] bool has_machfs() const;
  void clear_machfs() ;
  [[nodiscard]] const ::MacHfsProto& machfs() const;
  [[nodiscard]] ::MacHfsProto* PROTOBUF_NULLABLE release_machfs();
  ::MacHfsProto* PROTOBUF_NONNULL mutable_machfs();
  void set_allocated_machfs(::MacHfsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_machfs(::MacHfsProto* PROTOBUF_NULLABLE value);
  ::MacHfsProto* PROTOBUF_NULLABLE unsafe_arena_release_machfs();

  private:
  const ::MacHfsProto& _internal_machfs() const;
  ::MacHfsProto* PROTOBUF_NONNULL _internal_mutable_machfs();

  public:
  // optional .CbmfsProto cbmfs = 7 [json_name = "cbmfs"];
  [[nodiscard]] bool has_cbmfs() const;
  void clear_cbmfs() ;
  [[nodiscard]] const ::CbmfsProto& cbmfs() const;
  [[nodiscard]] ::CbmfsProto* PROTOBUF_NULLABLE release_cbmfs();
  ::CbmfsProto* PROTOBUF_NONNULL mutable_cbmfs();
  void set_allocated_cbmfs(::CbmfsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_cbmfs(::CbmfsProto* PROTOBUF_NULLABLE value);
  ::CbmfsProto* PROTOBUF_NULLABLE unsafe_arena_release_cbmfs();

  private:
  const ::CbmfsProto& _internal_cbmfs() const;
  ::CbmfsProto* PROTOBUF_NONNULL _internal_mutable_cbmfs();

  public:
  // optional .ProdosProto prodos = 8 [json_name = "prodos"];
  [[nodiscard]] bool has_prodos() const;
  void clear_prodos() ;
  [[nodiscard]] const ::ProdosProto& prodos() const;
  [[nodiscard]] ::ProdosProto* PROTOBUF_NULLABLE release_prodos();
  ::ProdosProto* PROTOBUF_NONNULL mutable_prodos();
  void set_allocated_prodos(::ProdosProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_prodos(::ProdosProto* PROTOBUF_NULLABLE value);
  ::ProdosProto* PROTOBUF_NULLABLE unsafe_arena_release_prodos();

  private:
  const ::ProdosProto& _internal_prodos() const;
  ::ProdosProto* PROTOBUF_NONNULL _internal_mutable_prodos();

  public:
  // optional .Smaky6FsProto smaky6 = 11 [json_name = "smaky6"];
  [[nodiscard]] bool has_smaky6() const;
  void clear_smaky6() ;
  [[nodiscard]] const ::Smaky6FsProto& smaky6() const;
  [[nodiscard]] ::Smaky6FsProto* PROTOBUF_NULLABLE release_smaky6();
  ::Smaky6FsProto* PROTOBUF_NONNULL mutable_smaky6();
  void set_allocated_smaky6(::Smaky6FsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_smaky6(::Smaky6FsProto* PROTOBUF_NULLABLE value);
  ::Smaky6FsProto* PROTOBUF_NULLABLE unsafe_arena_release_smaky6();

  private:
  const ::Smaky6FsProto& _internal_smaky6() const;
  ::Smaky6FsProto* PROTOBUF_NONNULL _internal_mutable_smaky6();

  public:
  // optional .AppledosProto appledos = 12 [json_name = "appledos"];
  [[nodiscard]] bool has_appledos() const;
  void clear_appledos() ;
  [[nodiscard]] const ::AppledosProto& appledos() const;
  [[nodiscard]] ::AppledosProto* PROTOBUF_NULLABLE release_appledos();
  ::AppledosProto* PROTOBUF_NONNULL mutable_appledos();
  void set_allocated_appledos(::AppledosProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_appledos(::AppledosProto* PROTOBUF_NULLABLE value);
  ::AppledosProto* PROTOBUF_NULLABLE unsafe_arena_release_appledos();

  private:
  const ::AppledosProto& _internal_appledos() const;
  ::AppledosProto* PROTOBUF_NONNULL _internal_mutable_appledos();

  public:
  // optional .PhileProto phile = 13 [json_name = "phile"];
  [[nodiscard]] bool has_phile() const;
  void clear_phile() ;
  [[nodiscard]] const ::PhileProto& phile() const;
  [[nodiscard]] ::PhileProto* PROTOBUF_NULLABLE release_phile();
  ::PhileProto* PROTOBUF_NONNULL mutable_phile();
  void set_allocated_phile(::PhileProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_phile(::PhileProto* PROTOBUF_NULLABLE value);
  ::PhileProto* PROTOBUF_NULLABLE unsafe_arena_release_phile();

  private:
  const ::PhileProto& _internal_phile() const;
  ::PhileProto* PROTOBUF_NONNULL _internal_mutable_phile();

  public:
  // optional .LifProto lif = 14 [json_name = "lif"];
  [[nodiscard]] bool has_lif() const;
  void clear_lif() ;
  [[nodiscard]] const ::LifProto& lif() const;
  [[nodiscard]] ::LifProto* PROTOBUF_NULLABLE release_lif();
  ::LifProto* PROTOBUF_NONNULL mutable_lif();
  void set_allocated_lif(::LifProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_lif(::LifProto* PROTOBUF_NULLABLE value);
  ::LifProto* PROTOBUF_NULLABLE unsafe_arena_release_lif();

  private:
  const ::LifProto& _internal_lif() const;
  ::LifProto* PROTOBUF_NONNULL _internal_mutable_lif();

  public:
  // optional .MicrodosProto microdos = 15 [json_name = "microdos"];
  [[nodiscard]] bool has_microdos() const;
  void clear_microdos() ;
  [[nodiscard]] const ::MicrodosProto& microdos() const;
  [[nodiscard]] ::MicrodosProto* PROTOBUF_NULLABLE release_microdos();
  ::MicrodosProto* PROTOBUF_NONNULL mutable_microdos();
  void set_allocated_microdos(::MicrodosProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_microdos(::MicrodosProto* PROTOBUF_NULLABLE value);
  ::MicrodosProto* PROTOBUF_NULLABLE unsafe_arena_release_microdos();

  private:
  const ::MicrodosProto& _internal_microdos() const;
  ::MicrodosProto* PROTOBUF_NONNULL _internal_mutable_microdos();

  public:
  // optional .ZDosProto zdos = 16 [json_name = "zdos"];
  [[nodiscard]] bool has_zdos() const;
  void clear_zdos() ;
  [[nodiscard]] const ::ZDosProto& zdos() const;
  [[nodiscard]] ::ZDosProto* PROTOBUF_NULLABLE release_zdos();
  ::ZDosProto* PROTOBUF_NONNULL mutable_zdos();
  void set_allocated_zdos(::ZDosProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_zdos(::ZDosProto* PROTOBUF_NULLABLE value);
  ::ZDosProto* PROTOBUF_NULLABLE unsafe_arena_release_zdos();

  private:
  const ::ZDosProto& _internal_zdos() const;
  ::ZDosProto* PROTOBUF_NONNULL _internal_mutable_zdos();

  public:
  // optional .RolandFsProto roland = 17 [json_name = "roland"];
  [[nodiscard]] bool has_roland() const;
  void clear_roland() ;
  [[nodiscard]] const ::RolandFsProto& roland() const;
  [[nodiscard]] ::RolandFsProto* PROTOBUF_NULLABLE release_roland();
  ::RolandFsProto* PROTOBUF_NONNULL mutable_roland();
  void set_allocated_roland(::RolandFsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_roland(::RolandFsProto* PROTOBUF_NULLABLE value);
  ::RolandFsProto* PROTOBUF_NULLABLE unsafe_arena_release_roland();

  private:
  const ::RolandFsProto& _internal_roland() const;
  ::RolandFsProto* PROTOBUF_NONNULL _internal_mutable_roland();

  public:
  // optional .FilesystemProto.FilesystemType type = 10 [default = NOT_SET, json_name = "type", (.help) = "filesystem type"];
  [[nodiscard]] bool has_type() const;
  void clear_type() ;
  [[nodiscard]] ::FilesystemProto_FilesystemType type() const;
  void set_type(::FilesystemProto_FilesystemType value);

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

  public:
  // @@protoc_insertion_point(class_scope:FilesystemProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<5, 16,
                          16, 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 FilesystemProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::AcornDfsProto* PROTOBUF_NULLABLE acorndfs_;
    ::Brother120FsProto* PROTOBUF_NULLABLE brother120_;
    ::FatFsProto* PROTOBUF_NULLABLE fatfs_;
    ::CpmFsProto* PROTOBUF_NULLABLE cpmfs_;
    ::AmigaFfsProto* PROTOBUF_NULLABLE amigaffs_;
    ::MacHfsProto* PROTOBUF_NULLABLE machfs_;
    ::CbmfsProto* PROTOBUF_NULLABLE cbmfs_;
    ::ProdosProto* PROTOBUF_NULLABLE prodos_;
    ::Smaky6FsProto* PROTOBUF_NULLABLE smaky6_;
    ::AppledosProto* PROTOBUF_NULLABLE appledos_;
    ::PhileProto* PROTOBUF_NULLABLE phile_;
    ::LifProto* PROTOBUF_NULLABLE lif_;
    ::MicrodosProto* PROTOBUF_NULLABLE microdos_;
    ::ZDosProto* PROTOBUF_NULLABLE zdos_;
    ::RolandFsProto* PROTOBUF_NULLABLE roland_;
    int type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fvfs_2fvfs_2eproto;
};

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




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


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

// AcornDfsProto

// optional .AcornDfsProto.Flavour flavour = 1 [default = ACORN_DFS, json_name = "flavour", (.help) = "which flavour of DFS to implement"];
inline bool AcornDfsProto::has_flavour() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void AcornDfsProto::clear_flavour() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.flavour_ = 1;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::AcornDfsProto_Flavour AcornDfsProto::flavour() const {
  // @@protoc_insertion_point(field_get:AcornDfsProto.flavour)
  return _internal_flavour();
}
inline void AcornDfsProto::set_flavour(::AcornDfsProto_Flavour value) {
  _internal_set_flavour(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:AcornDfsProto.flavour)
}
inline ::AcornDfsProto_Flavour AcornDfsProto::_internal_flavour() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::AcornDfsProto_Flavour>(_impl_.flavour_);
}
inline void AcornDfsProto::_internal_set_flavour(::AcornDfsProto_Flavour value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::AcornDfsProto_Flavour_internal_data_));
                                          _impl_.flavour_ = value;
}

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

// Brother120FsProto

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

// FatFsProto

// optional uint32 cluster_size = 1 [default = 0, json_name = "clusterSize", (.help) = "cluster size (for new filesystems); 0 to select automatically"];
inline bool FatFsProto::has_cluster_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void FatFsProto::clear_cluster_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cluster_size_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint32_t FatFsProto::cluster_size() const {
  // @@protoc_insertion_point(field_get:FatFsProto.cluster_size)
  return _internal_cluster_size();
}
inline void FatFsProto::set_cluster_size(::uint32_t value) {
  _internal_set_cluster_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:FatFsProto.cluster_size)
}
inline ::uint32_t FatFsProto::_internal_cluster_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cluster_size_;
}
inline void FatFsProto::_internal_set_cluster_size(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cluster_size_ = value;
}

// optional uint32 root_directory_entries = 2 [default = 0, json_name = "rootDirectoryEntries", (.help) = "number of entries in the root directory (for new filesystems); 0 to select automatically"];
inline bool FatFsProto::has_root_directory_entries() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void FatFsProto::clear_root_directory_entries() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.root_directory_entries_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint32_t FatFsProto::root_directory_entries() const {
  // @@protoc_insertion_point(field_get:FatFsProto.root_directory_entries)
  return _internal_root_directory_entries();
}
inline void FatFsProto::set_root_directory_entries(::uint32_t value) {
  _internal_set_root_directory_entries(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:FatFsProto.root_directory_entries)
}
inline ::uint32_t FatFsProto::_internal_root_directory_entries() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.root_directory_entries_;
}
inline void FatFsProto::_internal_set_root_directory_entries(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.root_directory_entries_ = value;
}

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

// CpmFsProto_Location

// optional uint32 track = 1 [json_name = "track", (.help) = "track number"];
inline bool CpmFsProto_Location::has_track() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void CpmFsProto_Location::clear_track() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.track_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint32_t CpmFsProto_Location::track() const {
  // @@protoc_insertion_point(field_get:CpmFsProto.Location.track)
  return _internal_track();
}
inline void CpmFsProto_Location::set_track(::uint32_t value) {
  _internal_set_track(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:CpmFsProto.Location.track)
}
inline ::uint32_t CpmFsProto_Location::_internal_track() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.track_;
}
inline void CpmFsProto_Location::_internal_set_track(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.track_ = value;
}

// optional uint32 side = 2 [json_name = "side", (.help) = "side number"];
inline bool CpmFsProto_Location::has_side() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void CpmFsProto_Location::clear_side() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.side_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint32_t CpmFsProto_Location::side() const {
  // @@protoc_insertion_point(field_get:CpmFsProto.Location.side)
  return _internal_side();
}
inline void CpmFsProto_Location::set_side(::uint32_t value) {
  _internal_set_side(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:CpmFsProto.Location.side)
}
inline ::uint32_t CpmFsProto_Location::_internal_side() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.side_;
}
inline void CpmFsProto_Location::_internal_set_side(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.side_ = value;
}

// optional uint32 sector = 3 [json_name = "sector", (.help) = "sector ID"];
inline bool CpmFsProto_Location::has_sector() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void CpmFsProto_Location::clear_sector() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sector_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint32_t CpmFsProto_Location::sector() const {
  // @@protoc_insertion_point(field_get:CpmFsProto.Location.sector)
  return _internal_sector();
}
inline void CpmFsProto_Location::set_sector(::uint32_t value) {
  _internal_set_sector(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:CpmFsProto.Location.sector)
}
inline ::uint32_t CpmFsProto_Location::_internal_sector() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.sector_;
}
inline void CpmFsProto_Location::_internal_set_sector(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sector_ = value;
}

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

// CpmFsProto_Padding

// optional uint32 amount = 1 [json_name = "amount", (.help) = "number of sectors of padding to insert"];
inline bool CpmFsProto_Padding::has_amount() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void CpmFsProto_Padding::clear_amount() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.amount_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint32_t CpmFsProto_Padding::amount() const {
  // @@protoc_insertion_point(field_get:CpmFsProto.Padding.amount)
  return _internal_amount();
}
inline void CpmFsProto_Padding::set_amount(::uint32_t value) {
  _internal_set_amount(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:CpmFsProto.Padding.amount)
}
inline ::uint32_t CpmFsProto_Padding::_internal_amount() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.amount_;
}
inline void CpmFsProto_Padding::_internal_set_amount(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.amount_ = value;
}

// optional uint32 every = 2 [json_name = "every", (.help) = "insert padding after this many sectors"];
inline bool CpmFsProto_Padding::has_every() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void CpmFsProto_Padding::clear_every() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.every_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint32_t CpmFsProto_Padding::every() const {
  // @@protoc_insertion_point(field_get:CpmFsProto.Padding.every)
  return _internal_every();
}
inline void CpmFsProto_Padding::set_every(::uint32_t value) {
  _internal_set_every(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:CpmFsProto.Padding.every)
}
inline ::uint32_t CpmFsProto_Padding::_internal_every() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.every_;
}
inline void CpmFsProto_Padding::_internal_set_every(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.every_ = value;
}

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

// CpmFsProto

// optional .CpmFsProto.Location filesystem_start = 1 [json_name = "filesystemStart", (.help) = "position of the start of the filesystem"];
inline bool CpmFsProto::has_filesystem_start() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.filesystem_start_ != nullptr);
  return value;
}
inline void CpmFsProto::clear_filesystem_start() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.filesystem_start_ != nullptr) _impl_.filesystem_start_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::CpmFsProto_Location& CpmFsProto::_internal_filesystem_start() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::CpmFsProto_Location* p = _impl_.filesystem_start_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::CpmFsProto_Location>(&::CpmFsProto_Location_globals_);
}
inline const ::CpmFsProto_Location& CpmFsProto::filesystem_start() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:CpmFsProto.filesystem_start)
  return _internal_filesystem_start();
}
inline void CpmFsProto::unsafe_arena_set_allocated_filesystem_start(
    ::CpmFsProto_Location* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.filesystem_start_);
  }
  _impl_.filesystem_start_ = reinterpret_cast<::CpmFsProto_Location*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CpmFsProto.filesystem_start)
}
inline ::CpmFsProto_Location* PROTOBUF_NULLABLE CpmFsProto::release_filesystem_start() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::CpmFsProto_Location* released = _impl_.filesystem_start_;
  _impl_.filesystem_start_ = 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 ::CpmFsProto_Location* PROTOBUF_NULLABLE CpmFsProto::unsafe_arena_release_filesystem_start() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:CpmFsProto.filesystem_start)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::CpmFsProto_Location* temp = _impl_.filesystem_start_;
  _impl_.filesystem_start_ = nullptr;
  return temp;
}
inline ::CpmFsProto_Location* PROTOBUF_NONNULL CpmFsProto::_internal_mutable_filesystem_start() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.filesystem_start_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::CpmFsProto_Location>(GetArena());
    _impl_.filesystem_start_ = reinterpret_cast<::CpmFsProto_Location*>(p);
  }
  return _impl_.filesystem_start_;
}
inline ::CpmFsProto_Location* PROTOBUF_NONNULL CpmFsProto::mutable_filesystem_start()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::CpmFsProto_Location* _msg = _internal_mutable_filesystem_start();
  // @@protoc_insertion_point(field_mutable:CpmFsProto.filesystem_start)
  return _msg;
}
inline void CpmFsProto::set_allocated_filesystem_start(::CpmFsProto_Location* 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_.filesystem_start_);
  }

  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], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }

  _impl_.filesystem_start_ = reinterpret_cast<::CpmFsProto_Location*>(value);
  // @@protoc_insertion_point(field_set_allocated:CpmFsProto.filesystem_start)
}

// optional int32 block_size = 2 [json_name = "blockSize", (.help) = "allocation block size"];
inline bool CpmFsProto::has_block_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void CpmFsProto::clear_block_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.block_size_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::int32_t CpmFsProto::block_size() const {
  // @@protoc_insertion_point(field_get:CpmFsProto.block_size)
  return _internal_block_size();
}
inline void CpmFsProto::set_block_size(::int32_t value) {
  _internal_set_block_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:CpmFsProto.block_size)
}
inline ::int32_t CpmFsProto::_internal_block_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.block_size_;
}
inline void CpmFsProto::_internal_set_block_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.block_size_ = value;
}

// optional int32 dir_entries = 3 [json_name = "dirEntries", (.help) = "number of entries in the directory"];
inline bool CpmFsProto::has_dir_entries() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void CpmFsProto::clear_dir_entries() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dir_entries_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::int32_t CpmFsProto::dir_entries() const {
  // @@protoc_insertion_point(field_get:CpmFsProto.dir_entries)
  return _internal_dir_entries();
}
inline void CpmFsProto::set_dir_entries(::int32_t value) {
  _internal_set_dir_entries(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:CpmFsProto.dir_entries)
}
inline ::int32_t CpmFsProto::_internal_dir_entries() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dir_entries_;
}
inline void CpmFsProto::_internal_set_dir_entries(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dir_entries_ = value;
}

// optional .CpmFsProto.Padding padding = 4 [json_name = "padding", (.help) = "wasted sectors not considered part of the filesystem"];
inline bool CpmFsProto::has_padding() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.padding_ != nullptr);
  return value;
}
inline void CpmFsProto::clear_padding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.padding_ != nullptr) _impl_.padding_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::CpmFsProto_Padding& CpmFsProto::_internal_padding() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::CpmFsProto_Padding* p = _impl_.padding_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::CpmFsProto_Padding>(&::CpmFsProto_Padding_globals_);
}
inline const ::CpmFsProto_Padding& CpmFsProto::padding() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:CpmFsProto.padding)
  return _internal_padding();
}
inline void CpmFsProto::unsafe_arena_set_allocated_padding(
    ::CpmFsProto_Padding* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.padding_);
  }
  _impl_.padding_ = reinterpret_cast<::CpmFsProto_Padding*>(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:CpmFsProto.padding)
}
inline ::CpmFsProto_Padding* PROTOBUF_NULLABLE CpmFsProto::release_padding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::CpmFsProto_Padding* released = _impl_.padding_;
  _impl_.padding_ = 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 ::CpmFsProto_Padding* PROTOBUF_NULLABLE CpmFsProto::unsafe_arena_release_padding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:CpmFsProto.padding)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::CpmFsProto_Padding* temp = _impl_.padding_;
  _impl_.padding_ = nullptr;
  return temp;
}
inline ::CpmFsProto_Padding* PROTOBUF_NONNULL CpmFsProto::_internal_mutable_padding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.padding_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::CpmFsProto_Padding>(GetArena());
    _impl_.padding_ = reinterpret_cast<::CpmFsProto_Padding*>(p);
  }
  return _impl_.padding_;
}
inline ::CpmFsProto_Padding* PROTOBUF_NONNULL CpmFsProto::mutable_padding()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::CpmFsProto_Padding* _msg = _internal_mutable_padding();
  // @@protoc_insertion_point(field_mutable:CpmFsProto.padding)
  return _msg;
}
inline void CpmFsProto::set_allocated_padding(::CpmFsProto_Padding* 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_.padding_);
  }

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

  _impl_.padding_ = reinterpret_cast<::CpmFsProto_Padding*>(value);
  // @@protoc_insertion_point(field_set_allocated:CpmFsProto.padding)
}

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

// AmigaFfsProto

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

// MacHfsProto

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

// CbmfsProto

// optional uint32 directory_track = 1 [default = 17, json_name = "directoryTrack", (.help) = "which track the directory is on (zero-based numbering)"];
inline bool CbmfsProto::has_directory_track() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void CbmfsProto::clear_directory_track() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_track_ = 17u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint32_t CbmfsProto::directory_track() const {
  // @@protoc_insertion_point(field_get:CbmfsProto.directory_track)
  return _internal_directory_track();
}
inline void CbmfsProto::set_directory_track(::uint32_t value) {
  _internal_set_directory_track(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:CbmfsProto.directory_track)
}
inline ::uint32_t CbmfsProto::_internal_directory_track() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.directory_track_;
}
inline void CbmfsProto::_internal_set_directory_track(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_track_ = value;
}

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

// ProdosProto

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

// AppledosProto

// optional uint32 filesystem_offset_sectors = 1 [default = 0, json_name = "filesystemOffsetSectors", (.help) = "offset the entire offset up the disk this many sectors"];
inline bool AppledosProto::has_filesystem_offset_sectors() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void AppledosProto::clear_filesystem_offset_sectors() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filesystem_offset_sectors_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint32_t AppledosProto::filesystem_offset_sectors() const {
  // @@protoc_insertion_point(field_get:AppledosProto.filesystem_offset_sectors)
  return _internal_filesystem_offset_sectors();
}
inline void AppledosProto::set_filesystem_offset_sectors(::uint32_t value) {
  _internal_set_filesystem_offset_sectors(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:AppledosProto.filesystem_offset_sectors)
}
inline ::uint32_t AppledosProto::_internal_filesystem_offset_sectors() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filesystem_offset_sectors_;
}
inline void AppledosProto::_internal_set_filesystem_offset_sectors(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filesystem_offset_sectors_ = value;
}

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

// Smaky6FsProto

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

// PhileProto

// optional uint32 block_size = 1 [default = 1024, json_name = "blockSize", (.help) = "Phile filesystem block size"];
inline bool PhileProto::has_block_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void PhileProto::clear_block_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.block_size_ = 1024u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint32_t PhileProto::block_size() const {
  // @@protoc_insertion_point(field_get:PhileProto.block_size)
  return _internal_block_size();
}
inline void PhileProto::set_block_size(::uint32_t value) {
  _internal_set_block_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:PhileProto.block_size)
}
inline ::uint32_t PhileProto::_internal_block_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.block_size_;
}
inline void PhileProto::_internal_set_block_size(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.block_size_ = value;
}

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

// LifProto

// optional uint32 block_size = 1 [default = 256, json_name = "blockSize", (.help) = "LIF filesystem block size"];
inline bool LifProto::has_block_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void LifProto::clear_block_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.block_size_ = 256u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint32_t LifProto::block_size() const {
  // @@protoc_insertion_point(field_get:LifProto.block_size)
  return _internal_block_size();
}
inline void LifProto::set_block_size(::uint32_t value) {
  _internal_set_block_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:LifProto.block_size)
}
inline ::uint32_t LifProto::_internal_block_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.block_size_;
}
inline void LifProto::_internal_set_block_size(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.block_size_ = value;
}

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

// MicrodosProto

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

// ZDosProto_Location

// optional uint32 track = 1 [json_name = "track", (.help) = "track number"];
inline bool ZDosProto_Location::has_track() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void ZDosProto_Location::clear_track() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.track_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint32_t ZDosProto_Location::track() const {
  // @@protoc_insertion_point(field_get:ZDosProto.Location.track)
  return _internal_track();
}
inline void ZDosProto_Location::set_track(::uint32_t value) {
  _internal_set_track(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:ZDosProto.Location.track)
}
inline ::uint32_t ZDosProto_Location::_internal_track() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.track_;
}
inline void ZDosProto_Location::_internal_set_track(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.track_ = value;
}

// optional uint32 sector = 3 [json_name = "sector", (.help) = "sector ID"];
inline bool ZDosProto_Location::has_sector() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void ZDosProto_Location::clear_sector() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sector_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint32_t ZDosProto_Location::sector() const {
  // @@protoc_insertion_point(field_get:ZDosProto.Location.sector)
  return _internal_sector();
}
inline void ZDosProto_Location::set_sector(::uint32_t value) {
  _internal_set_sector(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:ZDosProto.Location.sector)
}
inline ::uint32_t ZDosProto_Location::_internal_sector() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.sector_;
}
inline void ZDosProto_Location::_internal_set_sector(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sector_ = value;
}

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

// ZDosProto

// optional .ZDosProto.Location filesystem_start = 1 [json_name = "filesystemStart", (.help) = "position of the filesystem superblock"];
inline bool ZDosProto::has_filesystem_start() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.filesystem_start_ != nullptr);
  return value;
}
inline void ZDosProto::clear_filesystem_start() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.filesystem_start_ != nullptr) _impl_.filesystem_start_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::ZDosProto_Location& ZDosProto::_internal_filesystem_start() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::ZDosProto_Location* p = _impl_.filesystem_start_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::ZDosProto_Location>(&::ZDosProto_Location_globals_);
}
inline const ::ZDosProto_Location& ZDosProto::filesystem_start() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ZDosProto.filesystem_start)
  return _internal_filesystem_start();
}
inline void ZDosProto::unsafe_arena_set_allocated_filesystem_start(
    ::ZDosProto_Location* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.filesystem_start_);
  }
  _impl_.filesystem_start_ = reinterpret_cast<::ZDosProto_Location*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ZDosProto.filesystem_start)
}
inline ::ZDosProto_Location* PROTOBUF_NULLABLE ZDosProto::release_filesystem_start() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::ZDosProto_Location* released = _impl_.filesystem_start_;
  _impl_.filesystem_start_ = 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 ::ZDosProto_Location* PROTOBUF_NULLABLE ZDosProto::unsafe_arena_release_filesystem_start() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ZDosProto.filesystem_start)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::ZDosProto_Location* temp = _impl_.filesystem_start_;
  _impl_.filesystem_start_ = nullptr;
  return temp;
}
inline ::ZDosProto_Location* PROTOBUF_NONNULL ZDosProto::_internal_mutable_filesystem_start() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.filesystem_start_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::ZDosProto_Location>(GetArena());
    _impl_.filesystem_start_ = reinterpret_cast<::ZDosProto_Location*>(p);
  }
  return _impl_.filesystem_start_;
}
inline ::ZDosProto_Location* PROTOBUF_NONNULL ZDosProto::mutable_filesystem_start()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::ZDosProto_Location* _msg = _internal_mutable_filesystem_start();
  // @@protoc_insertion_point(field_mutable:ZDosProto.filesystem_start)
  return _msg;
}
inline void ZDosProto::set_allocated_filesystem_start(::ZDosProto_Location* 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_.filesystem_start_);
  }

  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], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }

  _impl_.filesystem_start_ = reinterpret_cast<::ZDosProto_Location*>(value);
  // @@protoc_insertion_point(field_set_allocated:ZDosProto.filesystem_start)
}

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

// RolandFsProto

// optional uint32 directory_track = 1 [default = 39, json_name = "directoryTrack", (.help) = "position of the directory"];
inline bool RolandFsProto::has_directory_track() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void RolandFsProto::clear_directory_track() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_track_ = 39u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint32_t RolandFsProto::directory_track() const {
  // @@protoc_insertion_point(field_get:RolandFsProto.directory_track)
  return _internal_directory_track();
}
inline void RolandFsProto::set_directory_track(::uint32_t value) {
  _internal_set_directory_track(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:RolandFsProto.directory_track)
}
inline ::uint32_t RolandFsProto::_internal_directory_track() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.directory_track_;
}
inline void RolandFsProto::_internal_set_directory_track(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_track_ = value;
}

// optional uint32 block_size = 2 [default = 3072, json_name = "blockSize", (.help) = "filesystem block size"];
inline bool RolandFsProto::has_block_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void RolandFsProto::clear_block_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.block_size_ = 3072u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint32_t RolandFsProto::block_size() const {
  // @@protoc_insertion_point(field_get:RolandFsProto.block_size)
  return _internal_block_size();
}
inline void RolandFsProto::set_block_size(::uint32_t value) {
  _internal_set_block_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:RolandFsProto.block_size)
}
inline ::uint32_t RolandFsProto::_internal_block_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.block_size_;
}
inline void RolandFsProto::_internal_set_block_size(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.block_size_ = value;
}

// optional uint32 directory_entries = 3 [default = 79, json_name = "directoryEntries", (.help) = "number of directory entries"];
inline bool RolandFsProto::has_directory_entries() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void RolandFsProto::clear_directory_entries() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_entries_ = 79u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint32_t RolandFsProto::directory_entries() const {
  // @@protoc_insertion_point(field_get:RolandFsProto.directory_entries)
  return _internal_directory_entries();
}
inline void RolandFsProto::set_directory_entries(::uint32_t value) {
  _internal_set_directory_entries(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:RolandFsProto.directory_entries)
}
inline ::uint32_t RolandFsProto::_internal_directory_entries() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.directory_entries_;
}
inline void RolandFsProto::_internal_set_directory_entries(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_entries_ = value;
}

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

// FilesystemProto

// optional .FilesystemProto.FilesystemType type = 10 [default = NOT_SET, json_name = "type", (.help) = "filesystem type"];
inline bool FilesystemProto::has_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00008000U);
  return value;
}
inline void FilesystemProto::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
}
inline ::FilesystemProto_FilesystemType FilesystemProto::type() const {
  // @@protoc_insertion_point(field_get:FilesystemProto.type)
  return _internal_type();
}
inline void FilesystemProto::set_type(::FilesystemProto_FilesystemType value) {
  _internal_set_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  // @@protoc_insertion_point(field_set:FilesystemProto.type)
}
inline ::FilesystemProto_FilesystemType FilesystemProto::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::FilesystemProto_FilesystemType>(_impl_.type_);
}
inline void FilesystemProto::_internal_set_type(::FilesystemProto_FilesystemType value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

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

// optional .AcornDfsProto acorndfs = 1 [json_name = "acorndfs"];
inline bool FilesystemProto::has_acorndfs() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.acorndfs_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_acorndfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.acorndfs_ != nullptr) _impl_.acorndfs_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::AcornDfsProto& FilesystemProto::_internal_acorndfs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::AcornDfsProto* p = _impl_.acorndfs_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::AcornDfsProto>(&::AcornDfsProto_globals_);
}
inline const ::AcornDfsProto& FilesystemProto::acorndfs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.acorndfs)
  return _internal_acorndfs();
}
inline void FilesystemProto::unsafe_arena_set_allocated_acorndfs(
    ::AcornDfsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.acorndfs_);
  }
  _impl_.acorndfs_ = reinterpret_cast<::AcornDfsProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FilesystemProto.acorndfs)
}
inline ::AcornDfsProto* PROTOBUF_NULLABLE FilesystemProto::release_acorndfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::AcornDfsProto* released = _impl_.acorndfs_;
  _impl_.acorndfs_ = 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 ::AcornDfsProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_acorndfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.acorndfs)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::AcornDfsProto* temp = _impl_.acorndfs_;
  _impl_.acorndfs_ = nullptr;
  return temp;
}
inline ::AcornDfsProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_acorndfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.acorndfs_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::AcornDfsProto>(GetArena());
    _impl_.acorndfs_ = reinterpret_cast<::AcornDfsProto*>(p);
  }
  return _impl_.acorndfs_;
}
inline ::AcornDfsProto* PROTOBUF_NONNULL FilesystemProto::mutable_acorndfs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::AcornDfsProto* _msg = _internal_mutable_acorndfs();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.acorndfs)
  return _msg;
}
inline void FilesystemProto::set_allocated_acorndfs(::AcornDfsProto* 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_.acorndfs_);
  }

  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], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }

  _impl_.acorndfs_ = reinterpret_cast<::AcornDfsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.acorndfs)
}

// optional .Brother120FsProto brother120 = 2 [json_name = "brother120"];
inline bool FilesystemProto::has_brother120() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.brother120_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_brother120() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.brother120_ != nullptr) _impl_.brother120_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::Brother120FsProto& FilesystemProto::_internal_brother120() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::Brother120FsProto* p = _impl_.brother120_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::Brother120FsProto>(&::Brother120FsProto_globals_);
}
inline const ::Brother120FsProto& FilesystemProto::brother120() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.brother120)
  return _internal_brother120();
}
inline void FilesystemProto::unsafe_arena_set_allocated_brother120(
    ::Brother120FsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.brother120_);
  }
  _impl_.brother120_ = reinterpret_cast<::Brother120FsProto*>(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:FilesystemProto.brother120)
}
inline ::Brother120FsProto* PROTOBUF_NULLABLE FilesystemProto::release_brother120() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::Brother120FsProto* released = _impl_.brother120_;
  _impl_.brother120_ = 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 ::Brother120FsProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_brother120() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.brother120)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::Brother120FsProto* temp = _impl_.brother120_;
  _impl_.brother120_ = nullptr;
  return temp;
}
inline ::Brother120FsProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_brother120() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.brother120_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::Brother120FsProto>(GetArena());
    _impl_.brother120_ = reinterpret_cast<::Brother120FsProto*>(p);
  }
  return _impl_.brother120_;
}
inline ::Brother120FsProto* PROTOBUF_NONNULL FilesystemProto::mutable_brother120()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::Brother120FsProto* _msg = _internal_mutable_brother120();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.brother120)
  return _msg;
}
inline void FilesystemProto::set_allocated_brother120(::Brother120FsProto* 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_.brother120_);
  }

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

  _impl_.brother120_ = reinterpret_cast<::Brother120FsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.brother120)
}

// optional .FatFsProto fatfs = 3 [json_name = "fatfs"];
inline bool FilesystemProto::has_fatfs() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.fatfs_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_fatfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.fatfs_ != nullptr) _impl_.fatfs_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::FatFsProto& FilesystemProto::_internal_fatfs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::FatFsProto* p = _impl_.fatfs_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::FatFsProto>(&::FatFsProto_globals_);
}
inline const ::FatFsProto& FilesystemProto::fatfs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.fatfs)
  return _internal_fatfs();
}
inline void FilesystemProto::unsafe_arena_set_allocated_fatfs(
    ::FatFsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.fatfs_);
  }
  _impl_.fatfs_ = reinterpret_cast<::FatFsProto*>(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:FilesystemProto.fatfs)
}
inline ::FatFsProto* PROTOBUF_NULLABLE FilesystemProto::release_fatfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::FatFsProto* released = _impl_.fatfs_;
  _impl_.fatfs_ = 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 ::FatFsProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_fatfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.fatfs)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::FatFsProto* temp = _impl_.fatfs_;
  _impl_.fatfs_ = nullptr;
  return temp;
}
inline ::FatFsProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_fatfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.fatfs_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::FatFsProto>(GetArena());
    _impl_.fatfs_ = reinterpret_cast<::FatFsProto*>(p);
  }
  return _impl_.fatfs_;
}
inline ::FatFsProto* PROTOBUF_NONNULL FilesystemProto::mutable_fatfs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::FatFsProto* _msg = _internal_mutable_fatfs();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.fatfs)
  return _msg;
}
inline void FilesystemProto::set_allocated_fatfs(::FatFsProto* 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_.fatfs_);
  }

  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_.fatfs_ = reinterpret_cast<::FatFsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.fatfs)
}

// optional .CpmFsProto cpmfs = 4 [json_name = "cpmfs"];
inline bool FilesystemProto::has_cpmfs() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.cpmfs_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_cpmfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.cpmfs_ != nullptr) _impl_.cpmfs_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::CpmFsProto& FilesystemProto::_internal_cpmfs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::CpmFsProto* p = _impl_.cpmfs_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::CpmFsProto>(&::CpmFsProto_globals_);
}
inline const ::CpmFsProto& FilesystemProto::cpmfs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.cpmfs)
  return _internal_cpmfs();
}
inline void FilesystemProto::unsafe_arena_set_allocated_cpmfs(
    ::CpmFsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cpmfs_);
  }
  _impl_.cpmfs_ = reinterpret_cast<::CpmFsProto*>(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:FilesystemProto.cpmfs)
}
inline ::CpmFsProto* PROTOBUF_NULLABLE FilesystemProto::release_cpmfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::CpmFsProto* released = _impl_.cpmfs_;
  _impl_.cpmfs_ = 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 ::CpmFsProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_cpmfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.cpmfs)

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::CpmFsProto* temp = _impl_.cpmfs_;
  _impl_.cpmfs_ = nullptr;
  return temp;
}
inline ::CpmFsProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_cpmfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.cpmfs_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::CpmFsProto>(GetArena());
    _impl_.cpmfs_ = reinterpret_cast<::CpmFsProto*>(p);
  }
  return _impl_.cpmfs_;
}
inline ::CpmFsProto* PROTOBUF_NONNULL FilesystemProto::mutable_cpmfs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::CpmFsProto* _msg = _internal_mutable_cpmfs();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.cpmfs)
  return _msg;
}
inline void FilesystemProto::set_allocated_cpmfs(::CpmFsProto* 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_.cpmfs_);
  }

  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_.cpmfs_ = reinterpret_cast<::CpmFsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.cpmfs)
}

// optional .AmigaFfsProto amigaffs = 5 [json_name = "amigaffs"];
inline bool FilesystemProto::has_amigaffs() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.amigaffs_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_amigaffs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.amigaffs_ != nullptr) _impl_.amigaffs_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::AmigaFfsProto& FilesystemProto::_internal_amigaffs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::AmigaFfsProto* p = _impl_.amigaffs_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::AmigaFfsProto>(&::AmigaFfsProto_globals_);
}
inline const ::AmigaFfsProto& FilesystemProto::amigaffs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.amigaffs)
  return _internal_amigaffs();
}
inline void FilesystemProto::unsafe_arena_set_allocated_amigaffs(
    ::AmigaFfsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.amigaffs_);
  }
  _impl_.amigaffs_ = reinterpret_cast<::AmigaFfsProto*>(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:FilesystemProto.amigaffs)
}
inline ::AmigaFfsProto* PROTOBUF_NULLABLE FilesystemProto::release_amigaffs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::AmigaFfsProto* released = _impl_.amigaffs_;
  _impl_.amigaffs_ = 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 ::AmigaFfsProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_amigaffs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.amigaffs)

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::AmigaFfsProto* temp = _impl_.amigaffs_;
  _impl_.amigaffs_ = nullptr;
  return temp;
}
inline ::AmigaFfsProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_amigaffs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.amigaffs_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::AmigaFfsProto>(GetArena());
    _impl_.amigaffs_ = reinterpret_cast<::AmigaFfsProto*>(p);
  }
  return _impl_.amigaffs_;
}
inline ::AmigaFfsProto* PROTOBUF_NONNULL FilesystemProto::mutable_amigaffs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::AmigaFfsProto* _msg = _internal_mutable_amigaffs();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.amigaffs)
  return _msg;
}
inline void FilesystemProto::set_allocated_amigaffs(::AmigaFfsProto* 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_.amigaffs_);
  }

  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_.amigaffs_ = reinterpret_cast<::AmigaFfsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.amigaffs)
}

// optional .MacHfsProto machfs = 6 [json_name = "machfs"];
inline bool FilesystemProto::has_machfs() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  PROTOBUF_ASSUME(!value || _impl_.machfs_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_machfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.machfs_ != nullptr) _impl_.machfs_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::MacHfsProto& FilesystemProto::_internal_machfs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MacHfsProto* p = _impl_.machfs_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MacHfsProto>(&::MacHfsProto_globals_);
}
inline const ::MacHfsProto& FilesystemProto::machfs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.machfs)
  return _internal_machfs();
}
inline void FilesystemProto::unsafe_arena_set_allocated_machfs(
    ::MacHfsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.machfs_);
  }
  _impl_.machfs_ = reinterpret_cast<::MacHfsProto*>(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:FilesystemProto.machfs)
}
inline ::MacHfsProto* PROTOBUF_NULLABLE FilesystemProto::release_machfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::MacHfsProto* released = _impl_.machfs_;
  _impl_.machfs_ = 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 ::MacHfsProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_machfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.machfs)

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::MacHfsProto* temp = _impl_.machfs_;
  _impl_.machfs_ = nullptr;
  return temp;
}
inline ::MacHfsProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_machfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.machfs_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MacHfsProto>(GetArena());
    _impl_.machfs_ = reinterpret_cast<::MacHfsProto*>(p);
  }
  return _impl_.machfs_;
}
inline ::MacHfsProto* PROTOBUF_NONNULL FilesystemProto::mutable_machfs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::MacHfsProto* _msg = _internal_mutable_machfs();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.machfs)
  return _msg;
}
inline void FilesystemProto::set_allocated_machfs(::MacHfsProto* 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_.machfs_);
  }

  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_.machfs_ = reinterpret_cast<::MacHfsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.machfs)
}

// optional .CbmfsProto cbmfs = 7 [json_name = "cbmfs"];
inline bool FilesystemProto::has_cbmfs() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  PROTOBUF_ASSUME(!value || _impl_.cbmfs_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_cbmfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.cbmfs_ != nullptr) _impl_.cbmfs_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::CbmfsProto& FilesystemProto::_internal_cbmfs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::CbmfsProto* p = _impl_.cbmfs_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::CbmfsProto>(&::CbmfsProto_globals_);
}
inline const ::CbmfsProto& FilesystemProto::cbmfs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.cbmfs)
  return _internal_cbmfs();
}
inline void FilesystemProto::unsafe_arena_set_allocated_cbmfs(
    ::CbmfsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cbmfs_);
  }
  _impl_.cbmfs_ = reinterpret_cast<::CbmfsProto*>(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:FilesystemProto.cbmfs)
}
inline ::CbmfsProto* PROTOBUF_NULLABLE FilesystemProto::release_cbmfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::CbmfsProto* released = _impl_.cbmfs_;
  _impl_.cbmfs_ = 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 ::CbmfsProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_cbmfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.cbmfs)

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::CbmfsProto* temp = _impl_.cbmfs_;
  _impl_.cbmfs_ = nullptr;
  return temp;
}
inline ::CbmfsProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_cbmfs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.cbmfs_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::CbmfsProto>(GetArena());
    _impl_.cbmfs_ = reinterpret_cast<::CbmfsProto*>(p);
  }
  return _impl_.cbmfs_;
}
inline ::CbmfsProto* PROTOBUF_NONNULL FilesystemProto::mutable_cbmfs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::CbmfsProto* _msg = _internal_mutable_cbmfs();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.cbmfs)
  return _msg;
}
inline void FilesystemProto::set_allocated_cbmfs(::CbmfsProto* 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_.cbmfs_);
  }

  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_.cbmfs_ = reinterpret_cast<::CbmfsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.cbmfs)
}

// optional .ProdosProto prodos = 8 [json_name = "prodos"];
inline bool FilesystemProto::has_prodos() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  PROTOBUF_ASSUME(!value || _impl_.prodos_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_prodos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.prodos_ != nullptr) _impl_.prodos_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::ProdosProto& FilesystemProto::_internal_prodos() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::ProdosProto* p = _impl_.prodos_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::ProdosProto>(&::ProdosProto_globals_);
}
inline const ::ProdosProto& FilesystemProto::prodos() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.prodos)
  return _internal_prodos();
}
inline void FilesystemProto::unsafe_arena_set_allocated_prodos(
    ::ProdosProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.prodos_);
  }
  _impl_.prodos_ = reinterpret_cast<::ProdosProto*>(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:FilesystemProto.prodos)
}
inline ::ProdosProto* PROTOBUF_NULLABLE FilesystemProto::release_prodos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::ProdosProto* released = _impl_.prodos_;
  _impl_.prodos_ = 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 ::ProdosProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_prodos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.prodos)

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::ProdosProto* temp = _impl_.prodos_;
  _impl_.prodos_ = nullptr;
  return temp;
}
inline ::ProdosProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_prodos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.prodos_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::ProdosProto>(GetArena());
    _impl_.prodos_ = reinterpret_cast<::ProdosProto*>(p);
  }
  return _impl_.prodos_;
}
inline ::ProdosProto* PROTOBUF_NONNULL FilesystemProto::mutable_prodos()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::ProdosProto* _msg = _internal_mutable_prodos();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.prodos)
  return _msg;
}
inline void FilesystemProto::set_allocated_prodos(::ProdosProto* 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_.prodos_);
  }

  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_.prodos_ = reinterpret_cast<::ProdosProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.prodos)
}

// optional .AppledosProto appledos = 12 [json_name = "appledos"];
inline bool FilesystemProto::has_appledos() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  PROTOBUF_ASSUME(!value || _impl_.appledos_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_appledos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.appledos_ != nullptr) _impl_.appledos_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline const ::AppledosProto& FilesystemProto::_internal_appledos() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::AppledosProto* p = _impl_.appledos_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::AppledosProto>(&::AppledosProto_globals_);
}
inline const ::AppledosProto& FilesystemProto::appledos() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.appledos)
  return _internal_appledos();
}
inline void FilesystemProto::unsafe_arena_set_allocated_appledos(
    ::AppledosProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.appledos_);
  }
  _impl_.appledos_ = reinterpret_cast<::AppledosProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FilesystemProto.appledos)
}
inline ::AppledosProto* PROTOBUF_NULLABLE FilesystemProto::release_appledos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::AppledosProto* released = _impl_.appledos_;
  _impl_.appledos_ = 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 ::AppledosProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_appledos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.appledos)

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::AppledosProto* temp = _impl_.appledos_;
  _impl_.appledos_ = nullptr;
  return temp;
}
inline ::AppledosProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_appledos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.appledos_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::AppledosProto>(GetArena());
    _impl_.appledos_ = reinterpret_cast<::AppledosProto*>(p);
  }
  return _impl_.appledos_;
}
inline ::AppledosProto* PROTOBUF_NONNULL FilesystemProto::mutable_appledos()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::AppledosProto* _msg = _internal_mutable_appledos();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.appledos)
  return _msg;
}
inline void FilesystemProto::set_allocated_appledos(::AppledosProto* 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_.appledos_);
  }

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

  _impl_.appledos_ = reinterpret_cast<::AppledosProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.appledos)
}

// optional .Smaky6FsProto smaky6 = 11 [json_name = "smaky6"];
inline bool FilesystemProto::has_smaky6() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.smaky6_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_smaky6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.smaky6_ != nullptr) _impl_.smaky6_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline const ::Smaky6FsProto& FilesystemProto::_internal_smaky6() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::Smaky6FsProto* p = _impl_.smaky6_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::Smaky6FsProto>(&::Smaky6FsProto_globals_);
}
inline const ::Smaky6FsProto& FilesystemProto::smaky6() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.smaky6)
  return _internal_smaky6();
}
inline void FilesystemProto::unsafe_arena_set_allocated_smaky6(
    ::Smaky6FsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.smaky6_);
  }
  _impl_.smaky6_ = reinterpret_cast<::Smaky6FsProto*>(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:FilesystemProto.smaky6)
}
inline ::Smaky6FsProto* PROTOBUF_NULLABLE FilesystemProto::release_smaky6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::Smaky6FsProto* released = _impl_.smaky6_;
  _impl_.smaky6_ = 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 ::Smaky6FsProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_smaky6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.smaky6)

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::Smaky6FsProto* temp = _impl_.smaky6_;
  _impl_.smaky6_ = nullptr;
  return temp;
}
inline ::Smaky6FsProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_smaky6() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.smaky6_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::Smaky6FsProto>(GetArena());
    _impl_.smaky6_ = reinterpret_cast<::Smaky6FsProto*>(p);
  }
  return _impl_.smaky6_;
}
inline ::Smaky6FsProto* PROTOBUF_NONNULL FilesystemProto::mutable_smaky6()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::Smaky6FsProto* _msg = _internal_mutable_smaky6();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.smaky6)
  return _msg;
}
inline void FilesystemProto::set_allocated_smaky6(::Smaky6FsProto* 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_.smaky6_);
  }

  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_.smaky6_ = reinterpret_cast<::Smaky6FsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.smaky6)
}

// optional .PhileProto phile = 13 [json_name = "phile"];
inline bool FilesystemProto::has_phile() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  PROTOBUF_ASSUME(!value || _impl_.phile_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_phile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.phile_ != nullptr) _impl_.phile_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline const ::PhileProto& FilesystemProto::_internal_phile() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::PhileProto* p = _impl_.phile_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::PhileProto>(&::PhileProto_globals_);
}
inline const ::PhileProto& FilesystemProto::phile() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.phile)
  return _internal_phile();
}
inline void FilesystemProto::unsafe_arena_set_allocated_phile(
    ::PhileProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.phile_);
  }
  _impl_.phile_ = reinterpret_cast<::PhileProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FilesystemProto.phile)
}
inline ::PhileProto* PROTOBUF_NULLABLE FilesystemProto::release_phile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::PhileProto* released = _impl_.phile_;
  _impl_.phile_ = 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 ::PhileProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_phile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.phile)

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::PhileProto* temp = _impl_.phile_;
  _impl_.phile_ = nullptr;
  return temp;
}
inline ::PhileProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_phile() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.phile_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::PhileProto>(GetArena());
    _impl_.phile_ = reinterpret_cast<::PhileProto*>(p);
  }
  return _impl_.phile_;
}
inline ::PhileProto* PROTOBUF_NONNULL FilesystemProto::mutable_phile()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::PhileProto* _msg = _internal_mutable_phile();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.phile)
  return _msg;
}
inline void FilesystemProto::set_allocated_phile(::PhileProto* 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_.phile_);
  }

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

  _impl_.phile_ = reinterpret_cast<::PhileProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.phile)
}

// optional .LifProto lif = 14 [json_name = "lif"];
inline bool FilesystemProto::has_lif() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  PROTOBUF_ASSUME(!value || _impl_.lif_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_lif() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.lif_ != nullptr) _impl_.lif_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline const ::LifProto& FilesystemProto::_internal_lif() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::LifProto* p = _impl_.lif_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::LifProto>(&::LifProto_globals_);
}
inline const ::LifProto& FilesystemProto::lif() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.lif)
  return _internal_lif();
}
inline void FilesystemProto::unsafe_arena_set_allocated_lif(
    ::LifProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.lif_);
  }
  _impl_.lif_ = reinterpret_cast<::LifProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FilesystemProto.lif)
}
inline ::LifProto* PROTOBUF_NULLABLE FilesystemProto::release_lif() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::LifProto* released = _impl_.lif_;
  _impl_.lif_ = 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 ::LifProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_lif() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.lif)

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::LifProto* temp = _impl_.lif_;
  _impl_.lif_ = nullptr;
  return temp;
}
inline ::LifProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_lif() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.lif_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::LifProto>(GetArena());
    _impl_.lif_ = reinterpret_cast<::LifProto*>(p);
  }
  return _impl_.lif_;
}
inline ::LifProto* PROTOBUF_NONNULL FilesystemProto::mutable_lif()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::LifProto* _msg = _internal_mutable_lif();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.lif)
  return _msg;
}
inline void FilesystemProto::set_allocated_lif(::LifProto* 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_.lif_);
  }

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

  _impl_.lif_ = reinterpret_cast<::LifProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.lif)
}

// optional .MicrodosProto microdos = 15 [json_name = "microdos"];
inline bool FilesystemProto::has_microdos() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  PROTOBUF_ASSUME(!value || _impl_.microdos_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_microdos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.microdos_ != nullptr) _impl_.microdos_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline const ::MicrodosProto& FilesystemProto::_internal_microdos() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MicrodosProto* p = _impl_.microdos_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MicrodosProto>(&::MicrodosProto_globals_);
}
inline const ::MicrodosProto& FilesystemProto::microdos() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.microdos)
  return _internal_microdos();
}
inline void FilesystemProto::unsafe_arena_set_allocated_microdos(
    ::MicrodosProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.microdos_);
  }
  _impl_.microdos_ = reinterpret_cast<::MicrodosProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FilesystemProto.microdos)
}
inline ::MicrodosProto* PROTOBUF_NULLABLE FilesystemProto::release_microdos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::MicrodosProto* released = _impl_.microdos_;
  _impl_.microdos_ = 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 ::MicrodosProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_microdos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.microdos)

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::MicrodosProto* temp = _impl_.microdos_;
  _impl_.microdos_ = nullptr;
  return temp;
}
inline ::MicrodosProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_microdos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.microdos_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MicrodosProto>(GetArena());
    _impl_.microdos_ = reinterpret_cast<::MicrodosProto*>(p);
  }
  return _impl_.microdos_;
}
inline ::MicrodosProto* PROTOBUF_NONNULL FilesystemProto::mutable_microdos()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::MicrodosProto* _msg = _internal_mutable_microdos();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.microdos)
  return _msg;
}
inline void FilesystemProto::set_allocated_microdos(::MicrodosProto* 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_.microdos_);
  }

  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], 0x00001000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  }

  _impl_.microdos_ = reinterpret_cast<::MicrodosProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.microdos)
}

// optional .ZDosProto zdos = 16 [json_name = "zdos"];
inline bool FilesystemProto::has_zdos() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  PROTOBUF_ASSUME(!value || _impl_.zdos_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_zdos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.zdos_ != nullptr) _impl_.zdos_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
}
inline const ::ZDosProto& FilesystemProto::_internal_zdos() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::ZDosProto* p = _impl_.zdos_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::ZDosProto>(&::ZDosProto_globals_);
}
inline const ::ZDosProto& FilesystemProto::zdos() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.zdos)
  return _internal_zdos();
}
inline void FilesystemProto::unsafe_arena_set_allocated_zdos(
    ::ZDosProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.zdos_);
  }
  _impl_.zdos_ = reinterpret_cast<::ZDosProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FilesystemProto.zdos)
}
inline ::ZDosProto* PROTOBUF_NULLABLE FilesystemProto::release_zdos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::ZDosProto* released = _impl_.zdos_;
  _impl_.zdos_ = 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 ::ZDosProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_zdos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.zdos)

  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::ZDosProto* temp = _impl_.zdos_;
  _impl_.zdos_ = nullptr;
  return temp;
}
inline ::ZDosProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_zdos() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.zdos_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::ZDosProto>(GetArena());
    _impl_.zdos_ = reinterpret_cast<::ZDosProto*>(p);
  }
  return _impl_.zdos_;
}
inline ::ZDosProto* PROTOBUF_NONNULL FilesystemProto::mutable_zdos()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::ZDosProto* _msg = _internal_mutable_zdos();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.zdos)
  return _msg;
}
inline void FilesystemProto::set_allocated_zdos(::ZDosProto* 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_.zdos_);
  }

  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], 0x00002000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  }

  _impl_.zdos_ = reinterpret_cast<::ZDosProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.zdos)
}

// optional .RolandFsProto roland = 17 [json_name = "roland"];
inline bool FilesystemProto::has_roland() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  PROTOBUF_ASSUME(!value || _impl_.roland_ != nullptr);
  return value;
}
inline void FilesystemProto::clear_roland() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.roland_ != nullptr) _impl_.roland_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
}
inline const ::RolandFsProto& FilesystemProto::_internal_roland() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::RolandFsProto* p = _impl_.roland_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::RolandFsProto>(&::RolandFsProto_globals_);
}
inline const ::RolandFsProto& FilesystemProto::roland() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FilesystemProto.roland)
  return _internal_roland();
}
inline void FilesystemProto::unsafe_arena_set_allocated_roland(
    ::RolandFsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.roland_);
  }
  _impl_.roland_ = reinterpret_cast<::RolandFsProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FilesystemProto.roland)
}
inline ::RolandFsProto* PROTOBUF_NULLABLE FilesystemProto::release_roland() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::RolandFsProto* released = _impl_.roland_;
  _impl_.roland_ = 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 ::RolandFsProto* PROTOBUF_NULLABLE FilesystemProto::unsafe_arena_release_roland() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FilesystemProto.roland)

  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::RolandFsProto* temp = _impl_.roland_;
  _impl_.roland_ = nullptr;
  return temp;
}
inline ::RolandFsProto* PROTOBUF_NONNULL FilesystemProto::_internal_mutable_roland() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.roland_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::RolandFsProto>(GetArena());
    _impl_.roland_ = reinterpret_cast<::RolandFsProto*>(p);
  }
  return _impl_.roland_;
}
inline ::RolandFsProto* PROTOBUF_NONNULL FilesystemProto::mutable_roland()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::RolandFsProto* _msg = _internal_mutable_roland();
  // @@protoc_insertion_point(field_mutable:FilesystemProto.roland)
  return _msg;
}
inline void FilesystemProto::set_allocated_roland(::RolandFsProto* 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_.roland_);
  }

  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], 0x00004000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  }

  _impl_.roland_ = reinterpret_cast<::RolandFsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FilesystemProto.roland)
}

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

// @@protoc_insertion_point(namespace_scope)


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::AcornDfsProto_Flavour> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::AcornDfsProto_Flavour>() {
  return ::AcornDfsProto_Flavour_descriptor();
}
template <>
struct is_proto_enum<::FilesystemProto_FilesystemType> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::FilesystemProto_FilesystemType>() {
  return ::FilesystemProto_FilesystemType_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

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

#endif  // lib_2fvfs_2fvfs_2eproto_2epb_2eh
