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

#ifndef arch_2fibm_2fibm_2eproto_2epb_2eh
#define arch_2fibm_2fibm_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_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/unknown_field_set.h"
#include "lib/config/common.pb.h"
// @@protoc_insertion_point(includes)

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

#define PROTOBUF_INTERNAL_EXPORT_arch_2fibm_2fibm_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_arch_2fibm_2fibm_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_arch_2fibm_2fibm_2eproto;
}  // extern "C"
class IbmDecoderProto;
struct IbmDecoderProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern IbmDecoderProtoGlobalsTypeInternal IbmDecoderProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull IbmDecoderProto_class_data_;
#else
extern const IbmDecoderProtoGlobalsTypeInternal IbmDecoderProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class IbmDecoderProto_TrackdataProto;
struct IbmDecoderProto_TrackdataProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern IbmDecoderProto_TrackdataProtoGlobalsTypeInternal IbmDecoderProto_TrackdataProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull IbmDecoderProto_TrackdataProto_class_data_;
#else
extern const IbmDecoderProto_TrackdataProtoGlobalsTypeInternal IbmDecoderProto_TrackdataProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class IbmEncoderProto;
struct IbmEncoderProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern IbmEncoderProtoGlobalsTypeInternal IbmEncoderProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull IbmEncoderProto_class_data_;
#else
extern const IbmEncoderProtoGlobalsTypeInternal IbmEncoderProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class IbmEncoderProto_TrackdataProto;
struct IbmEncoderProto_TrackdataProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern IbmEncoderProto_TrackdataProtoGlobalsTypeInternal IbmEncoderProto_TrackdataProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull IbmEncoderProto_TrackdataProto_class_data_;
#else
extern const IbmEncoderProto_TrackdataProtoGlobalsTypeInternal IbmEncoderProto_TrackdataProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google


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


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

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

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

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

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

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

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

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

  explicit IbmEncoderProto_TrackdataProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  IbmEncoderProto_TrackdataProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const IbmEncoderProto_TrackdataProto& from);
  IbmEncoderProto_TrackdataProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, IbmEncoderProto_TrackdataProto&& from) noexcept
      : IbmEncoderProto_TrackdataProto(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 {
    kUseFmFieldNumber = 6,
    kTrackFieldNumber = 15,
    kHeadFieldNumber = 16,
    kInvertSideByteFieldNumber = 19,
    kTargetRotationalPeriodMsFieldNumber = 1,
    kTargetClockPeriodUsFieldNumber = 5,
    kEmitIamFieldNumber = 3,
    kIdamByteFieldNumber = 7,
    kDamByteFieldNumber = 8,
    kGap0FieldNumber = 9,
    kGap1FieldNumber = 10,
    kGap2FieldNumber = 11,
    kGap3FieldNumber = 12,
    kGapFillByteFieldNumber = 18,
  };
  // optional bool use_fm = 6 [default = false, json_name = "useFm", (.help) = "whether to use FM encoding rather than MFM"];
  [[nodiscard]] bool has_use_fm() const;
  void clear_use_fm() ;
  [[nodiscard]] bool use_fm() const;
  void set_use_fm(bool value);

  private:
  bool _internal_use_fm() const;
  void _internal_set_use_fm(bool value);

  public:
  // optional int32 track = 15 [json_name = "track", (.help) = "if set, the format applies only to this track"];
  [[nodiscard]] bool has_track() const;
  void clear_track() ;
  [[nodiscard]] ::int32_t track() const;
  void set_track(::int32_t value);

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

  public:
  // optional int32 head = 16 [json_name = "head", (.help) = "if set, the format applies only to this head"];
  [[nodiscard]] bool has_head() const;
  void clear_head() ;
  [[nodiscard]] ::int32_t head() const;
  void set_head(::int32_t value);

  private:
  ::int32_t _internal_head() const;
  void _internal_set_head(::int32_t value);

  public:
  // optional bool invert_side_byte = 19 [default = false, json_name = "invertSideByte", (.help) = "invert the side byte before writing"];
  [[nodiscard]] bool has_invert_side_byte() const;
  void clear_invert_side_byte() ;
  [[nodiscard]] bool invert_side_byte() const;
  void set_invert_side_byte(bool value);

  private:
  bool _internal_invert_side_byte() const;
  void _internal_set_invert_side_byte(bool value);

  public:
  // optional double target_rotational_period_ms = 1 [default = 200, json_name = "targetRotationalPeriodMs", (.help) = "rotational period of target disk"];
  [[nodiscard]] bool has_target_rotational_period_ms() const;
  void clear_target_rotational_period_ms() ;
  [[nodiscard]] double target_rotational_period_ms() const;
  void set_target_rotational_period_ms(double value);

  private:
  double _internal_target_rotational_period_ms() const;
  void _internal_set_target_rotational_period_ms(double value);

  public:
  // optional double target_clock_period_us = 5 [default = 4, json_name = "targetClockPeriodUs", (.help) = "data clock rate on target disk"];
  [[nodiscard]] bool has_target_clock_period_us() const;
  void clear_target_clock_period_us() ;
  [[nodiscard]] double target_clock_period_us() const;
  void set_target_clock_period_us(double value);

  private:
  double _internal_target_clock_period_us() const;
  void _internal_set_target_clock_period_us(double value);

  public:
  // optional bool emit_iam = 3 [default = true, json_name = "emitIam", (.help) = "whether to emit an IAM record"];
  [[nodiscard]] bool has_emit_iam() const;
  void clear_emit_iam() ;
  [[nodiscard]] bool emit_iam() const;
  void set_emit_iam(bool value);

  private:
  bool _internal_emit_iam() const;
  void _internal_set_emit_iam(bool value);

  public:
  // optional int32 idam_byte = 7 [default = 21844, json_name = "idamByte", (.help) = "16-bit raw bit pattern of IDAM byte"];
  [[nodiscard]] bool has_idam_byte() const;
  void clear_idam_byte() ;
  [[nodiscard]] ::int32_t idam_byte() const;
  void set_idam_byte(::int32_t value);

  private:
  ::int32_t _internal_idam_byte() const;
  void _internal_set_idam_byte(::int32_t value);

  public:
  // optional int32 dam_byte = 8 [default = 21829, json_name = "damByte", (.help) = "16-bit raw bit pattern of DAM byte"];
  [[nodiscard]] bool has_dam_byte() const;
  void clear_dam_byte() ;
  [[nodiscard]] ::int32_t dam_byte() const;
  void set_dam_byte(::int32_t value);

  private:
  ::int32_t _internal_dam_byte() const;
  void _internal_set_dam_byte(::int32_t value);

  public:
  // optional int32 gap0 = 9 [default = 80, json_name = "gap0", (.help) = "size of gap 1 (the post-index gap)"];
  [[nodiscard]] bool has_gap0() const;
  void clear_gap0() ;
  [[nodiscard]] ::int32_t gap0() const;
  void set_gap0(::int32_t value);

  private:
  ::int32_t _internal_gap0() const;
  void _internal_set_gap0(::int32_t value);

  public:
  // optional int32 gap1 = 10 [default = 50, json_name = "gap1", (.help) = "size of gap 2 (the post-ID gap)"];
  [[nodiscard]] bool has_gap1() const;
  void clear_gap1() ;
  [[nodiscard]] ::int32_t gap1() const;
  void set_gap1(::int32_t value);

  private:
  ::int32_t _internal_gap1() const;
  void _internal_set_gap1(::int32_t value);

  public:
  // optional int32 gap2 = 11 [default = 22, json_name = "gap2", (.help) = "size of gap 3 (the pre-data gap)"];
  [[nodiscard]] bool has_gap2() const;
  void clear_gap2() ;
  [[nodiscard]] ::int32_t gap2() const;
  void set_gap2(::int32_t value);

  private:
  ::int32_t _internal_gap2() const;
  void _internal_set_gap2(::int32_t value);

  public:
  // optional int32 gap3 = 12 [default = 80, json_name = "gap3", (.help) = "size of gap 4 (the post-data or format gap)"];
  [[nodiscard]] bool has_gap3() const;
  void clear_gap3() ;
  [[nodiscard]] ::int32_t gap3() const;
  void set_gap3(::int32_t value);

  private:
  ::int32_t _internal_gap3() const;
  void _internal_set_gap3(::int32_t value);

  public:
  // optional int32 gap_fill_byte = 18 [default = 37460, json_name = "gapFillByte", (.help) = "16-bit raw bit pattern of gap fill byte"];
  [[nodiscard]] bool has_gap_fill_byte() const;
  void clear_gap_fill_byte() ;
  [[nodiscard]] ::int32_t gap_fill_byte() const;
  void set_gap_fill_byte(::int32_t value);

  private:
  ::int32_t _internal_gap_fill_byte() const;
  void _internal_set_gap_fill_byte(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:IbmEncoderProto.TrackdataProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<4, 14,
                          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 IbmEncoderProto_TrackdataProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    bool use_fm_;
    ::int32_t track_;
    ::int32_t head_;
    bool invert_side_byte_;
    double target_rotational_period_ms_;
    double target_clock_period_us_;
    bool emit_iam_;
    ::int32_t idam_byte_;
    ::int32_t dam_byte_;
    ::int32_t gap0_;
    ::int32_t gap1_;
    ::int32_t gap2_;
    ::int32_t gap3_;
    ::int32_t gap_fill_byte_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_arch_2fibm_2fibm_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  explicit IbmDecoderProto_TrackdataProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  IbmDecoderProto_TrackdataProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const IbmDecoderProto_TrackdataProto& from);
  IbmDecoderProto_TrackdataProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, IbmDecoderProto_TrackdataProto&& from) noexcept
      : IbmDecoderProto_TrackdataProto(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 {
    kIgnoreSideByteFieldNumber = 2,
    kInvertSideByteFieldNumber = 4,
    kIgnoreTrackByteFieldNumber = 6,
    kTrackFieldNumber = 7,
    kHeadFieldNumber = 8,
    kIgnoreSectorFieldNumber = 10,
  };
  // optional bool ignore_side_byte = 2 [default = false, json_name = "ignoreSideByte", (.help) = "ignore side byte in sector header"];
  [[nodiscard]] bool has_ignore_side_byte() const;
  void clear_ignore_side_byte() ;
  [[nodiscard]] bool ignore_side_byte() const;
  void set_ignore_side_byte(bool value);

  private:
  bool _internal_ignore_side_byte() const;
  void _internal_set_ignore_side_byte(bool value);

  public:
  // optional bool invert_side_byte = 4 [default = false, json_name = "invertSideByte", (.help) = "invert the side byte in the sector header"];
  [[nodiscard]] bool has_invert_side_byte() const;
  void clear_invert_side_byte() ;
  [[nodiscard]] bool invert_side_byte() const;
  void set_invert_side_byte(bool value);

  private:
  bool _internal_invert_side_byte() const;
  void _internal_set_invert_side_byte(bool value);

  public:
  // optional bool ignore_track_byte = 6 [default = false, json_name = "ignoreTrackByte", (.help) = "ignore track byte in sector header"];
  [[nodiscard]] bool has_ignore_track_byte() const;
  void clear_ignore_track_byte() ;
  [[nodiscard]] bool ignore_track_byte() const;
  void set_ignore_track_byte(bool value);

  private:
  bool _internal_ignore_track_byte() const;
  void _internal_set_ignore_track_byte(bool value);

  public:
  // optional int32 track = 7 [json_name = "track", (.help) = "if set, the format applies only to this track"];
  [[nodiscard]] bool has_track() const;
  void clear_track() ;
  [[nodiscard]] ::int32_t track() const;
  void set_track(::int32_t value);

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

  public:
  // optional int32 head = 8 [json_name = "head", (.help) = "if set, the format applies only to this head"];
  [[nodiscard]] bool has_head() const;
  void clear_head() ;
  [[nodiscard]] ::int32_t head() const;
  void set_head(::int32_t value);

  private:
  ::int32_t _internal_head() const;
  void _internal_set_head(::int32_t value);

  public:
  // repeated int32 ignore_sector = 10 [json_name = "ignoreSector", (.help) = "sectors with these IDs will not be read"];
  [[nodiscard]] int ignore_sector_size() const;
  private:
  int _internal_ignore_sector_size() const;

  public:
  void clear_ignore_sector() ;
  [[nodiscard]] ::int32_t ignore_sector(int index) const;
  void set_ignore_sector(int index, ::int32_t value);
  void add_ignore_sector(::int32_t value);
  [[nodiscard]] const ::google::protobuf::RepeatedField<::int32_t>& ignore_sector()
      const;
  ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL mutable_ignore_sector();

  private:
  const ::google::protobuf::RepeatedField<::int32_t>& _internal_ignore_sector() const;
  ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL _internal_mutable_ignore_sector();

  public:
  // @@protoc_insertion_point(class_scope:IbmDecoderProto.TrackdataProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 6,
                          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 IbmDecoderProto_TrackdataProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    bool ignore_side_byte_;
    bool invert_side_byte_;
    bool ignore_track_byte_;
    ::int32_t track_;
    ::int32_t head_;
    ::google::protobuf::RepeatedField<::int32_t> ignore_sector_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_arch_2fibm_2fibm_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  // accessors -------------------------------------------------------
  enum : int {
    kTrackdataFieldNumber = 1,
  };
  // repeated .IbmEncoderProto.TrackdataProto trackdata = 1 [json_name = "trackdata"];
  [[nodiscard]] int trackdata_size() const;
  private:
  int _internal_trackdata_size() const;

  public:
  void clear_trackdata() ;
  [[nodiscard]] const ::IbmEncoderProto_TrackdataProto& trackdata(int index) const;
  [[nodiscard]] ::IbmEncoderProto_TrackdataProto* PROTOBUF_NONNULL mutable_trackdata(int index);
  ::IbmEncoderProto_TrackdataProto* PROTOBUF_NONNULL add_trackdata();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::IbmEncoderProto_TrackdataProto>&
  trackdata() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::IbmEncoderProto_TrackdataProto>* PROTOBUF_NONNULL
  mutable_trackdata();

  private:
  const ::google::protobuf::RepeatedPtrField<::IbmEncoderProto_TrackdataProto>& _internal_trackdata() const;
  ::google::protobuf::RepeatedPtrField<::IbmEncoderProto_TrackdataProto>* PROTOBUF_NONNULL _internal_mutable_trackdata();

  public:
  // @@protoc_insertion_point(class_scope:IbmEncoderProto)
 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 IbmEncoderProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::IbmEncoderProto_TrackdataProto > trackdata_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_arch_2fibm_2fibm_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  // accessors -------------------------------------------------------
  enum : int {
    kTrackdataFieldNumber = 1,
  };
  // repeated .IbmDecoderProto.TrackdataProto trackdata = 1 [json_name = "trackdata"];
  [[nodiscard]] int trackdata_size() const;
  private:
  int _internal_trackdata_size() const;

  public:
  void clear_trackdata() ;
  [[nodiscard]] const ::IbmDecoderProto_TrackdataProto& trackdata(int index) const;
  [[nodiscard]] ::IbmDecoderProto_TrackdataProto* PROTOBUF_NONNULL mutable_trackdata(int index);
  ::IbmDecoderProto_TrackdataProto* PROTOBUF_NONNULL add_trackdata();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::IbmDecoderProto_TrackdataProto>&
  trackdata() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::IbmDecoderProto_TrackdataProto>* PROTOBUF_NONNULL
  mutable_trackdata();

  private:
  const ::google::protobuf::RepeatedPtrField<::IbmDecoderProto_TrackdataProto>& _internal_trackdata() const;
  ::google::protobuf::RepeatedPtrField<::IbmDecoderProto_TrackdataProto>* PROTOBUF_NONNULL _internal_mutable_trackdata();

  public:
  // @@protoc_insertion_point(class_scope:IbmDecoderProto)
 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 IbmDecoderProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::IbmDecoderProto_TrackdataProto > trackdata_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_arch_2fibm_2fibm_2eproto;
};

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




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


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

// IbmDecoderProto_TrackdataProto

// optional int32 track = 7 [json_name = "track", (.help) = "if set, the format applies only to this track"];
inline bool IbmDecoderProto_TrackdataProto::has_track() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void IbmDecoderProto_TrackdataProto::clear_track() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.track_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::int32_t IbmDecoderProto_TrackdataProto::track() const {
  // @@protoc_insertion_point(field_get:IbmDecoderProto.TrackdataProto.track)
  return _internal_track();
}
inline void IbmDecoderProto_TrackdataProto::set_track(::int32_t value) {
  _internal_set_track(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:IbmDecoderProto.TrackdataProto.track)
}
inline ::int32_t IbmDecoderProto_TrackdataProto::_internal_track() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.track_;
}
inline void IbmDecoderProto_TrackdataProto::_internal_set_track(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.track_ = value;
}

// optional int32 head = 8 [json_name = "head", (.help) = "if set, the format applies only to this head"];
inline bool IbmDecoderProto_TrackdataProto::has_head() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void IbmDecoderProto_TrackdataProto::clear_head() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.head_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline ::int32_t IbmDecoderProto_TrackdataProto::head() const {
  // @@protoc_insertion_point(field_get:IbmDecoderProto.TrackdataProto.head)
  return _internal_head();
}
inline void IbmDecoderProto_TrackdataProto::set_head(::int32_t value) {
  _internal_set_head(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:IbmDecoderProto.TrackdataProto.head)
}
inline ::int32_t IbmDecoderProto_TrackdataProto::_internal_head() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.head_;
}
inline void IbmDecoderProto_TrackdataProto::_internal_set_head(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.head_ = value;
}

// optional bool ignore_side_byte = 2 [default = false, json_name = "ignoreSideByte", (.help) = "ignore side byte in sector header"];
inline bool IbmDecoderProto_TrackdataProto::has_ignore_side_byte() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void IbmDecoderProto_TrackdataProto::clear_ignore_side_byte() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ignore_side_byte_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline bool IbmDecoderProto_TrackdataProto::ignore_side_byte() const {
  // @@protoc_insertion_point(field_get:IbmDecoderProto.TrackdataProto.ignore_side_byte)
  return _internal_ignore_side_byte();
}
inline void IbmDecoderProto_TrackdataProto::set_ignore_side_byte(bool value) {
  _internal_set_ignore_side_byte(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:IbmDecoderProto.TrackdataProto.ignore_side_byte)
}
inline bool IbmDecoderProto_TrackdataProto::_internal_ignore_side_byte() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ignore_side_byte_;
}
inline void IbmDecoderProto_TrackdataProto::_internal_set_ignore_side_byte(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ignore_side_byte_ = value;
}

// optional bool ignore_track_byte = 6 [default = false, json_name = "ignoreTrackByte", (.help) = "ignore track byte in sector header"];
inline bool IbmDecoderProto_TrackdataProto::has_ignore_track_byte() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void IbmDecoderProto_TrackdataProto::clear_ignore_track_byte() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ignore_track_byte_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline bool IbmDecoderProto_TrackdataProto::ignore_track_byte() const {
  // @@protoc_insertion_point(field_get:IbmDecoderProto.TrackdataProto.ignore_track_byte)
  return _internal_ignore_track_byte();
}
inline void IbmDecoderProto_TrackdataProto::set_ignore_track_byte(bool value) {
  _internal_set_ignore_track_byte(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:IbmDecoderProto.TrackdataProto.ignore_track_byte)
}
inline bool IbmDecoderProto_TrackdataProto::_internal_ignore_track_byte() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ignore_track_byte_;
}
inline void IbmDecoderProto_TrackdataProto::_internal_set_ignore_track_byte(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ignore_track_byte_ = value;
}

// optional bool invert_side_byte = 4 [default = false, json_name = "invertSideByte", (.help) = "invert the side byte in the sector header"];
inline bool IbmDecoderProto_TrackdataProto::has_invert_side_byte() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void IbmDecoderProto_TrackdataProto::clear_invert_side_byte() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.invert_side_byte_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline bool IbmDecoderProto_TrackdataProto::invert_side_byte() const {
  // @@protoc_insertion_point(field_get:IbmDecoderProto.TrackdataProto.invert_side_byte)
  return _internal_invert_side_byte();
}
inline void IbmDecoderProto_TrackdataProto::set_invert_side_byte(bool value) {
  _internal_set_invert_side_byte(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:IbmDecoderProto.TrackdataProto.invert_side_byte)
}
inline bool IbmDecoderProto_TrackdataProto::_internal_invert_side_byte() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.invert_side_byte_;
}
inline void IbmDecoderProto_TrackdataProto::_internal_set_invert_side_byte(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.invert_side_byte_ = value;
}

// repeated int32 ignore_sector = 10 [json_name = "ignoreSector", (.help) = "sectors with these IDs will not be read"];
inline int IbmDecoderProto_TrackdataProto::_internal_ignore_sector_size() const {
  return _internal_ignore_sector().size();
}
inline int IbmDecoderProto_TrackdataProto::ignore_sector_size() const {
  return _internal_ignore_sector_size();
}
inline void IbmDecoderProto_TrackdataProto::clear_ignore_sector() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ignore_sector_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline ::int32_t IbmDecoderProto_TrackdataProto::ignore_sector(int index) const {
  // @@protoc_insertion_point(field_get:IbmDecoderProto.TrackdataProto.ignore_sector)
  return _internal_ignore_sector().Get(index);
}
inline void IbmDecoderProto_TrackdataProto::set_ignore_sector(int index, ::int32_t value) {
  _internal_mutable_ignore_sector()->Set(index, value);
  // @@protoc_insertion_point(field_set:IbmDecoderProto.TrackdataProto.ignore_sector)
}
inline void IbmDecoderProto_TrackdataProto::add_ignore_sector(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_ignore_sector()
      ->InternalAddWithArena<const ::google::protobuf::MessageLite*>(
          internal_visibility(), this, value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_add:IbmDecoderProto.TrackdataProto.ignore_sector)
}
inline const ::google::protobuf::RepeatedField<::int32_t>& IbmDecoderProto_TrackdataProto::ignore_sector() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:IbmDecoderProto.TrackdataProto.ignore_sector)
  return _internal_ignore_sector();
}
inline ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL IbmDecoderProto_TrackdataProto::mutable_ignore_sector()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_mutable_list:IbmDecoderProto.TrackdataProto.ignore_sector)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_ignore_sector();
}
inline const ::google::protobuf::RepeatedField<::int32_t>&
IbmDecoderProto_TrackdataProto::_internal_ignore_sector() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ignore_sector_;
}
inline ::google::protobuf::RepeatedField<::int32_t>* PROTOBUF_NONNULL
IbmDecoderProto_TrackdataProto::_internal_mutable_ignore_sector() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.ignore_sector_;
}

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

// IbmDecoderProto

// repeated .IbmDecoderProto.TrackdataProto trackdata = 1 [json_name = "trackdata"];
inline int IbmDecoderProto::_internal_trackdata_size() const {
  return _internal_trackdata().size();
}
inline int IbmDecoderProto::trackdata_size() const {
  return _internal_trackdata_size();
}
inline void IbmDecoderProto::clear_trackdata() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.trackdata_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::IbmDecoderProto_TrackdataProto& IbmDecoderProto::trackdata(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:IbmDecoderProto.trackdata)
  return _internal_trackdata().Get(index);
}
inline ::IbmDecoderProto_TrackdataProto* PROTOBUF_NONNULL IbmDecoderProto::mutable_trackdata(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:IbmDecoderProto.trackdata)
  return _internal_mutable_trackdata()->Mutable(index);
}
inline ::IbmDecoderProto_TrackdataProto* PROTOBUF_NONNULL IbmDecoderProto::add_trackdata()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::IbmDecoderProto_TrackdataProto* _add =
      _internal_mutable_trackdata()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:IbmDecoderProto.trackdata)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::IbmDecoderProto_TrackdataProto>& IbmDecoderProto::trackdata() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:IbmDecoderProto.trackdata)
  return _internal_trackdata();
}
inline ::google::protobuf::RepeatedPtrField<::IbmDecoderProto_TrackdataProto>* PROTOBUF_NONNULL
IbmDecoderProto::mutable_trackdata() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:IbmDecoderProto.trackdata)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_trackdata();
}
inline const ::google::protobuf::RepeatedPtrField<::IbmDecoderProto_TrackdataProto>&
IbmDecoderProto::_internal_trackdata() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.trackdata_;
}
inline ::google::protobuf::RepeatedPtrField<::IbmDecoderProto_TrackdataProto>* PROTOBUF_NONNULL
IbmDecoderProto::_internal_mutable_trackdata() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.trackdata_;
}

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

// IbmEncoderProto_TrackdataProto

// optional int32 track = 15 [json_name = "track", (.help) = "if set, the format applies only to this track"];
inline bool IbmEncoderProto_TrackdataProto::has_track() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_track() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.track_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::int32_t IbmEncoderProto_TrackdataProto::track() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.track)
  return _internal_track();
}
inline void IbmEncoderProto_TrackdataProto::set_track(::int32_t value) {
  _internal_set_track(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.track)
}
inline ::int32_t IbmEncoderProto_TrackdataProto::_internal_track() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.track_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_track(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.track_ = value;
}

// optional int32 head = 16 [json_name = "head", (.help) = "if set, the format applies only to this head"];
inline bool IbmEncoderProto_TrackdataProto::has_head() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_head() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.head_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::int32_t IbmEncoderProto_TrackdataProto::head() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.head)
  return _internal_head();
}
inline void IbmEncoderProto_TrackdataProto::set_head(::int32_t value) {
  _internal_set_head(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.head)
}
inline ::int32_t IbmEncoderProto_TrackdataProto::_internal_head() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.head_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_head(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.head_ = value;
}

// optional bool emit_iam = 3 [default = true, json_name = "emitIam", (.help) = "whether to emit an IAM record"];
inline bool IbmEncoderProto_TrackdataProto::has_emit_iam() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_emit_iam() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.emit_iam_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline bool IbmEncoderProto_TrackdataProto::emit_iam() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.emit_iam)
  return _internal_emit_iam();
}
inline void IbmEncoderProto_TrackdataProto::set_emit_iam(bool value) {
  _internal_set_emit_iam(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.emit_iam)
}
inline bool IbmEncoderProto_TrackdataProto::_internal_emit_iam() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.emit_iam_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_emit_iam(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.emit_iam_ = value;
}

// optional double target_clock_period_us = 5 [default = 4, json_name = "targetClockPeriodUs", (.help) = "data clock rate on target disk"];
inline bool IbmEncoderProto_TrackdataProto::has_target_clock_period_us() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_target_clock_period_us() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_clock_period_us_ = 4;
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline double IbmEncoderProto_TrackdataProto::target_clock_period_us() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.target_clock_period_us)
  return _internal_target_clock_period_us();
}
inline void IbmEncoderProto_TrackdataProto::set_target_clock_period_us(double value) {
  _internal_set_target_clock_period_us(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.target_clock_period_us)
}
inline double IbmEncoderProto_TrackdataProto::_internal_target_clock_period_us() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.target_clock_period_us_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_target_clock_period_us(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_clock_period_us_ = value;
}

// optional bool use_fm = 6 [default = false, json_name = "useFm", (.help) = "whether to use FM encoding rather than MFM"];
inline bool IbmEncoderProto_TrackdataProto::has_use_fm() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_use_fm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_fm_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline bool IbmEncoderProto_TrackdataProto::use_fm() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.use_fm)
  return _internal_use_fm();
}
inline void IbmEncoderProto_TrackdataProto::set_use_fm(bool value) {
  _internal_set_use_fm(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.use_fm)
}
inline bool IbmEncoderProto_TrackdataProto::_internal_use_fm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_fm_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_use_fm(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_fm_ = value;
}

// optional int32 idam_byte = 7 [default = 21844, json_name = "idamByte", (.help) = "16-bit raw bit pattern of IDAM byte"];
inline bool IbmEncoderProto_TrackdataProto::has_idam_byte() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_idam_byte() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.idam_byte_ = 21844;
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline ::int32_t IbmEncoderProto_TrackdataProto::idam_byte() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.idam_byte)
  return _internal_idam_byte();
}
inline void IbmEncoderProto_TrackdataProto::set_idam_byte(::int32_t value) {
  _internal_set_idam_byte(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.idam_byte)
}
inline ::int32_t IbmEncoderProto_TrackdataProto::_internal_idam_byte() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.idam_byte_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_idam_byte(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.idam_byte_ = value;
}

// optional int32 dam_byte = 8 [default = 21829, json_name = "damByte", (.help) = "16-bit raw bit pattern of DAM byte"];
inline bool IbmEncoderProto_TrackdataProto::has_dam_byte() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_dam_byte() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dam_byte_ = 21829;
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline ::int32_t IbmEncoderProto_TrackdataProto::dam_byte() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.dam_byte)
  return _internal_dam_byte();
}
inline void IbmEncoderProto_TrackdataProto::set_dam_byte(::int32_t value) {
  _internal_set_dam_byte(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.dam_byte)
}
inline ::int32_t IbmEncoderProto_TrackdataProto::_internal_dam_byte() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dam_byte_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_dam_byte(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dam_byte_ = value;
}

// optional int32 gap0 = 9 [default = 80, json_name = "gap0", (.help) = "size of gap 1 (the post-index gap)"];
inline bool IbmEncoderProto_TrackdataProto::has_gap0() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_gap0() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gap0_ = 80;
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline ::int32_t IbmEncoderProto_TrackdataProto::gap0() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.gap0)
  return _internal_gap0();
}
inline void IbmEncoderProto_TrackdataProto::set_gap0(::int32_t value) {
  _internal_set_gap0(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.gap0)
}
inline ::int32_t IbmEncoderProto_TrackdataProto::_internal_gap0() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.gap0_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_gap0(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gap0_ = value;
}

// optional int32 gap1 = 10 [default = 50, json_name = "gap1", (.help) = "size of gap 2 (the post-ID gap)"];
inline bool IbmEncoderProto_TrackdataProto::has_gap1() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_gap1() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gap1_ = 50;
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline ::int32_t IbmEncoderProto_TrackdataProto::gap1() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.gap1)
  return _internal_gap1();
}
inline void IbmEncoderProto_TrackdataProto::set_gap1(::int32_t value) {
  _internal_set_gap1(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.gap1)
}
inline ::int32_t IbmEncoderProto_TrackdataProto::_internal_gap1() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.gap1_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_gap1(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gap1_ = value;
}

// optional int32 gap2 = 11 [default = 22, json_name = "gap2", (.help) = "size of gap 3 (the pre-data gap)"];
inline bool IbmEncoderProto_TrackdataProto::has_gap2() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_gap2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gap2_ = 22;
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline ::int32_t IbmEncoderProto_TrackdataProto::gap2() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.gap2)
  return _internal_gap2();
}
inline void IbmEncoderProto_TrackdataProto::set_gap2(::int32_t value) {
  _internal_set_gap2(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.gap2)
}
inline ::int32_t IbmEncoderProto_TrackdataProto::_internal_gap2() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.gap2_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_gap2(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gap2_ = value;
}

// optional int32 gap3 = 12 [default = 80, json_name = "gap3", (.help) = "size of gap 4 (the post-data or format gap)"];
inline bool IbmEncoderProto_TrackdataProto::has_gap3() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_gap3() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gap3_ = 80;
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline ::int32_t IbmEncoderProto_TrackdataProto::gap3() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.gap3)
  return _internal_gap3();
}
inline void IbmEncoderProto_TrackdataProto::set_gap3(::int32_t value) {
  _internal_set_gap3(value);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.gap3)
}
inline ::int32_t IbmEncoderProto_TrackdataProto::_internal_gap3() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.gap3_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_gap3(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gap3_ = value;
}

// optional bool invert_side_byte = 19 [default = false, json_name = "invertSideByte", (.help) = "invert the side byte before writing"];
inline bool IbmEncoderProto_TrackdataProto::has_invert_side_byte() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_invert_side_byte() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.invert_side_byte_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline bool IbmEncoderProto_TrackdataProto::invert_side_byte() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.invert_side_byte)
  return _internal_invert_side_byte();
}
inline void IbmEncoderProto_TrackdataProto::set_invert_side_byte(bool value) {
  _internal_set_invert_side_byte(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.invert_side_byte)
}
inline bool IbmEncoderProto_TrackdataProto::_internal_invert_side_byte() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.invert_side_byte_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_invert_side_byte(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.invert_side_byte_ = value;
}

// optional int32 gap_fill_byte = 18 [default = 37460, json_name = "gapFillByte", (.help) = "16-bit raw bit pattern of gap fill byte"];
inline bool IbmEncoderProto_TrackdataProto::has_gap_fill_byte() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_gap_fill_byte() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gap_fill_byte_ = 37460;
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
}
inline ::int32_t IbmEncoderProto_TrackdataProto::gap_fill_byte() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.gap_fill_byte)
  return _internal_gap_fill_byte();
}
inline void IbmEncoderProto_TrackdataProto::set_gap_fill_byte(::int32_t value) {
  _internal_set_gap_fill_byte(value);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.gap_fill_byte)
}
inline ::int32_t IbmEncoderProto_TrackdataProto::_internal_gap_fill_byte() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.gap_fill_byte_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_gap_fill_byte(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gap_fill_byte_ = value;
}

// optional double target_rotational_period_ms = 1 [default = 200, json_name = "targetRotationalPeriodMs", (.help) = "rotational period of target disk"];
inline bool IbmEncoderProto_TrackdataProto::has_target_rotational_period_ms() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void IbmEncoderProto_TrackdataProto::clear_target_rotational_period_ms() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_rotational_period_ms_ = 200;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline double IbmEncoderProto_TrackdataProto::target_rotational_period_ms() const {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.TrackdataProto.target_rotational_period_ms)
  return _internal_target_rotational_period_ms();
}
inline void IbmEncoderProto_TrackdataProto::set_target_rotational_period_ms(double value) {
  _internal_set_target_rotational_period_ms(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:IbmEncoderProto.TrackdataProto.target_rotational_period_ms)
}
inline double IbmEncoderProto_TrackdataProto::_internal_target_rotational_period_ms() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.target_rotational_period_ms_;
}
inline void IbmEncoderProto_TrackdataProto::_internal_set_target_rotational_period_ms(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_rotational_period_ms_ = value;
}

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

// IbmEncoderProto

// repeated .IbmEncoderProto.TrackdataProto trackdata = 1 [json_name = "trackdata"];
inline int IbmEncoderProto::_internal_trackdata_size() const {
  return _internal_trackdata().size();
}
inline int IbmEncoderProto::trackdata_size() const {
  return _internal_trackdata_size();
}
inline void IbmEncoderProto::clear_trackdata() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.trackdata_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::IbmEncoderProto_TrackdataProto& IbmEncoderProto::trackdata(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:IbmEncoderProto.trackdata)
  return _internal_trackdata().Get(index);
}
inline ::IbmEncoderProto_TrackdataProto* PROTOBUF_NONNULL IbmEncoderProto::mutable_trackdata(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:IbmEncoderProto.trackdata)
  return _internal_mutable_trackdata()->Mutable(index);
}
inline ::IbmEncoderProto_TrackdataProto* PROTOBUF_NONNULL IbmEncoderProto::add_trackdata()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::IbmEncoderProto_TrackdataProto* _add =
      _internal_mutable_trackdata()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:IbmEncoderProto.trackdata)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::IbmEncoderProto_TrackdataProto>& IbmEncoderProto::trackdata() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:IbmEncoderProto.trackdata)
  return _internal_trackdata();
}
inline ::google::protobuf::RepeatedPtrField<::IbmEncoderProto_TrackdataProto>* PROTOBUF_NONNULL
IbmEncoderProto::mutable_trackdata() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:IbmEncoderProto.trackdata)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_trackdata();
}
inline const ::google::protobuf::RepeatedPtrField<::IbmEncoderProto_TrackdataProto>&
IbmEncoderProto::_internal_trackdata() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.trackdata_;
}
inline ::google::protobuf::RepeatedPtrField<::IbmEncoderProto_TrackdataProto>* PROTOBUF_NONNULL
IbmEncoderProto::_internal_mutable_trackdata() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.trackdata_;
}

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

// @@protoc_insertion_point(namespace_scope)


// @@protoc_insertion_point(global_scope)

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

#endif  // arch_2fibm_2fibm_2eproto_2epb_2eh
