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

#ifndef futatabi_5fmidi_5fmapping_2eproto_2epb_2eh
#define futatabi_5fmidi_5fmapping_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 "midi_mapping.pb.h"
// @@protoc_insertion_point(includes)

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

#define PROTOBUF_INTERNAL_EXPORT_futatabi_5fmidi_5fmapping_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_futatabi_5fmidi_5fmapping_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_futatabi_5fmidi_5fmapping_2eproto;
}  // extern "C"
class CameraMIDIMappingProto;
struct CameraMIDIMappingProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern CameraMIDIMappingProtoGlobalsTypeInternal CameraMIDIMappingProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull CameraMIDIMappingProto_class_data_;
#else
extern const CameraMIDIMappingProtoGlobalsTypeInternal CameraMIDIMappingProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class MIDIMappingProto;
struct MIDIMappingProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern MIDIMappingProtoGlobalsTypeInternal MIDIMappingProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull MIDIMappingProto_class_data_;
#else
extern const MIDIMappingProtoGlobalsTypeInternal MIDIMappingProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google


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


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

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

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

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

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

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

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

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

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

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  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(CameraMIDIMappingProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "CameraMIDIMappingProto"; }

  explicit CameraMIDIMappingProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  CameraMIDIMappingProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const CameraMIDIMappingProto& from);
  CameraMIDIMappingProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, CameraMIDIMappingProto&& from) noexcept
      : CameraMIDIMappingProto(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 {
    kButtonFieldNumber = 1,
    kIsCurrentFieldNumber = 3,
    kBankFieldNumber = 2,
  };
  // optional .MIDIButtonProto button = 1;
  [[nodiscard]] bool has_button() const;
  void clear_button() ;
  [[nodiscard]] const ::MIDIButtonProto& button() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_button();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_button();
  void set_allocated_button(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_button(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_button();

  private:
  const ::MIDIButtonProto& _internal_button() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_button();

  public:
  // optional .MIDILightProto is_current = 3;
  [[nodiscard]] bool has_is_current() const;
  void clear_is_current() ;
  [[nodiscard]] const ::MIDILightProto& is_current() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_is_current();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_is_current();
  void set_allocated_is_current(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_is_current(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_is_current();

  private:
  const ::MIDILightProto& _internal_is_current() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_is_current();

  public:
  // optional int32 bank = 2;
  [[nodiscard]] bool has_bank() const;
  void clear_bank() ;
  [[nodiscard]] ::int32_t bank() const;
  void set_bank(::int32_t value);

  private:
  ::int32_t _internal_bank() const;
  void _internal_set_bank(::int32_t value);

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

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

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

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

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

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

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

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

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

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

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  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(MIDIMappingProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "MIDIMappingProto"; }

  explicit MIDIMappingProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  MIDIMappingProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const MIDIMappingProto& from);
  MIDIMappingProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, MIDIMappingProto&& from) noexcept
      : MIDIMappingProto(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 {
    kPrevBankFieldNumber = 2,
    kNextBankFieldNumber = 3,
    kSelectBank1FieldNumber = 4,
    kSelectBank2FieldNumber = 5,
    kSelectBank3FieldNumber = 6,
    kSelectBank4FieldNumber = 7,
    kSelectBank5FieldNumber = 8,
    kBank1IsSelectedFieldNumber = 9,
    kBank2IsSelectedFieldNumber = 10,
    kBank3IsSelectedFieldNumber = 11,
    kBank4IsSelectedFieldNumber = 12,
    kBank5IsSelectedFieldNumber = 13,
    kJogFieldNumber = 16,
    kPreviewFieldNumber = 18,
    kPreviewReadyFieldNumber = 20,
    kQueueFieldNumber = 21,
    kQueueEnabledFieldNumber = 23,
    kPlayFieldNumber = 24,
    kPlayingFieldNumber = 26,
    kCueInFieldNumber = 27,
    kCueInEnabledFieldNumber = 29,
    kCueOutFieldNumber = 30,
    kNumControllerBanksFieldNumber = 1,
    kJogBankFieldNumber = 17,
    kPreviewBankFieldNumber = 19,
    kQueueBankFieldNumber = 22,
    kPlayBankFieldNumber = 25,
    kCueInBankFieldNumber = 28,
    kCueOutBankFieldNumber = 31,
    kCameraFieldNumber = 33,
    kCueOutEnabledFieldNumber = 32,
    kMasterSpeedFieldNumber = 34,
    kToggleLockFieldNumber = 36,
    kLockedFieldNumber = 38,
    kLockedBlinkingFieldNumber = 39,
    kPlayReadyFieldNumber = 40,
    kPreviewPlayingFieldNumber = 41,
    kMasterSpeedLightFieldNumber = 42,
    kNextFieldNumber = 45,
    kNextReadyFieldNumber = 47,
    kMasterSpeedBankFieldNumber = 35,
    kToggleLockBankFieldNumber = 37,
    kMasterSpeedLightMinFieldNumber = 43,
    kNextButtonBankFieldNumber = 46,
    kMasterSpeedLightMaxFieldNumber = 44,
  };
  // optional .MIDIButtonProto prev_bank = 2;
  [[nodiscard]] bool has_prev_bank() const;
  void clear_prev_bank() ;
  [[nodiscard]] const ::MIDIButtonProto& prev_bank() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_prev_bank();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_prev_bank();
  void set_allocated_prev_bank(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_prev_bank(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_prev_bank();

  private:
  const ::MIDIButtonProto& _internal_prev_bank() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_prev_bank();

  public:
  // optional .MIDIButtonProto next_bank = 3;
  [[nodiscard]] bool has_next_bank() const;
  void clear_next_bank() ;
  [[nodiscard]] const ::MIDIButtonProto& next_bank() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_next_bank();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_next_bank();
  void set_allocated_next_bank(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_next_bank(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_next_bank();

  private:
  const ::MIDIButtonProto& _internal_next_bank() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_next_bank();

  public:
  // optional .MIDIButtonProto select_bank_1 = 4;
  [[nodiscard]] bool has_select_bank_1() const;
  void clear_select_bank_1() ;
  [[nodiscard]] const ::MIDIButtonProto& select_bank_1() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_select_bank_1();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_select_bank_1();
  void set_allocated_select_bank_1(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_select_bank_1(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_select_bank_1();

  private:
  const ::MIDIButtonProto& _internal_select_bank_1() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_select_bank_1();

  public:
  // optional .MIDIButtonProto select_bank_2 = 5;
  [[nodiscard]] bool has_select_bank_2() const;
  void clear_select_bank_2() ;
  [[nodiscard]] const ::MIDIButtonProto& select_bank_2() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_select_bank_2();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_select_bank_2();
  void set_allocated_select_bank_2(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_select_bank_2(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_select_bank_2();

  private:
  const ::MIDIButtonProto& _internal_select_bank_2() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_select_bank_2();

  public:
  // optional .MIDIButtonProto select_bank_3 = 6;
  [[nodiscard]] bool has_select_bank_3() const;
  void clear_select_bank_3() ;
  [[nodiscard]] const ::MIDIButtonProto& select_bank_3() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_select_bank_3();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_select_bank_3();
  void set_allocated_select_bank_3(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_select_bank_3(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_select_bank_3();

  private:
  const ::MIDIButtonProto& _internal_select_bank_3() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_select_bank_3();

  public:
  // optional .MIDIButtonProto select_bank_4 = 7;
  [[nodiscard]] bool has_select_bank_4() const;
  void clear_select_bank_4() ;
  [[nodiscard]] const ::MIDIButtonProto& select_bank_4() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_select_bank_4();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_select_bank_4();
  void set_allocated_select_bank_4(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_select_bank_4(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_select_bank_4();

  private:
  const ::MIDIButtonProto& _internal_select_bank_4() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_select_bank_4();

  public:
  // optional .MIDIButtonProto select_bank_5 = 8;
  [[nodiscard]] bool has_select_bank_5() const;
  void clear_select_bank_5() ;
  [[nodiscard]] const ::MIDIButtonProto& select_bank_5() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_select_bank_5();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_select_bank_5();
  void set_allocated_select_bank_5(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_select_bank_5(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_select_bank_5();

  private:
  const ::MIDIButtonProto& _internal_select_bank_5() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_select_bank_5();

  public:
  // optional .MIDILightProto bank_1_is_selected = 9;
  [[nodiscard]] bool has_bank_1_is_selected() const;
  void clear_bank_1_is_selected() ;
  [[nodiscard]] const ::MIDILightProto& bank_1_is_selected() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_bank_1_is_selected();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_bank_1_is_selected();
  void set_allocated_bank_1_is_selected(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_bank_1_is_selected(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_bank_1_is_selected();

  private:
  const ::MIDILightProto& _internal_bank_1_is_selected() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_bank_1_is_selected();

  public:
  // optional .MIDILightProto bank_2_is_selected = 10;
  [[nodiscard]] bool has_bank_2_is_selected() const;
  void clear_bank_2_is_selected() ;
  [[nodiscard]] const ::MIDILightProto& bank_2_is_selected() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_bank_2_is_selected();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_bank_2_is_selected();
  void set_allocated_bank_2_is_selected(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_bank_2_is_selected(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_bank_2_is_selected();

  private:
  const ::MIDILightProto& _internal_bank_2_is_selected() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_bank_2_is_selected();

  public:
  // optional .MIDILightProto bank_3_is_selected = 11;
  [[nodiscard]] bool has_bank_3_is_selected() const;
  void clear_bank_3_is_selected() ;
  [[nodiscard]] const ::MIDILightProto& bank_3_is_selected() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_bank_3_is_selected();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_bank_3_is_selected();
  void set_allocated_bank_3_is_selected(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_bank_3_is_selected(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_bank_3_is_selected();

  private:
  const ::MIDILightProto& _internal_bank_3_is_selected() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_bank_3_is_selected();

  public:
  // optional .MIDILightProto bank_4_is_selected = 12;
  [[nodiscard]] bool has_bank_4_is_selected() const;
  void clear_bank_4_is_selected() ;
  [[nodiscard]] const ::MIDILightProto& bank_4_is_selected() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_bank_4_is_selected();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_bank_4_is_selected();
  void set_allocated_bank_4_is_selected(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_bank_4_is_selected(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_bank_4_is_selected();

  private:
  const ::MIDILightProto& _internal_bank_4_is_selected() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_bank_4_is_selected();

  public:
  // optional .MIDILightProto bank_5_is_selected = 13;
  [[nodiscard]] bool has_bank_5_is_selected() const;
  void clear_bank_5_is_selected() ;
  [[nodiscard]] const ::MIDILightProto& bank_5_is_selected() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_bank_5_is_selected();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_bank_5_is_selected();
  void set_allocated_bank_5_is_selected(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_bank_5_is_selected(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_bank_5_is_selected();

  private:
  const ::MIDILightProto& _internal_bank_5_is_selected() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_bank_5_is_selected();

  public:
  // optional .MIDIControllerProto jog = 16;
  [[nodiscard]] bool has_jog() const;
  void clear_jog() ;
  [[nodiscard]] const ::MIDIControllerProto& jog() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_jog();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_jog();
  void set_allocated_jog(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_jog(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_jog();

  private:
  const ::MIDIControllerProto& _internal_jog() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_jog();

  public:
  // optional .MIDIButtonProto preview = 18;
  [[nodiscard]] bool has_preview() const;
  void clear_preview() ;
  [[nodiscard]] const ::MIDIButtonProto& preview() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_preview();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_preview();
  void set_allocated_preview(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_preview(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_preview();

  private:
  const ::MIDIButtonProto& _internal_preview() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_preview();

  public:
  // optional .MIDILightProto preview_ready = 20;
  [[nodiscard]] bool has_preview_ready() const;
  void clear_preview_ready() ;
  [[nodiscard]] const ::MIDILightProto& preview_ready() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_preview_ready();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_preview_ready();
  void set_allocated_preview_ready(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_preview_ready(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_preview_ready();

  private:
  const ::MIDILightProto& _internal_preview_ready() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_preview_ready();

  public:
  // optional .MIDIButtonProto queue = 21;
  [[nodiscard]] bool has_queue() const;
  void clear_queue() ;
  [[nodiscard]] const ::MIDIButtonProto& queue() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_queue();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_queue();
  void set_allocated_queue(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_queue(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_queue();

  private:
  const ::MIDIButtonProto& _internal_queue() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_queue();

  public:
  // optional .MIDILightProto queue_enabled = 23;
  [[nodiscard]] bool has_queue_enabled() const;
  void clear_queue_enabled() ;
  [[nodiscard]] const ::MIDILightProto& queue_enabled() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_queue_enabled();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_queue_enabled();
  void set_allocated_queue_enabled(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_queue_enabled(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_queue_enabled();

  private:
  const ::MIDILightProto& _internal_queue_enabled() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_queue_enabled();

  public:
  // optional .MIDIButtonProto play = 24;
  [[nodiscard]] bool has_play() const;
  void clear_play() ;
  [[nodiscard]] const ::MIDIButtonProto& play() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_play();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_play();
  void set_allocated_play(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_play(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_play();

  private:
  const ::MIDIButtonProto& _internal_play() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_play();

  public:
  // optional .MIDILightProto playing = 26;
  [[nodiscard]] bool has_playing() const;
  void clear_playing() ;
  [[nodiscard]] const ::MIDILightProto& playing() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_playing();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_playing();
  void set_allocated_playing(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_playing(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_playing();

  private:
  const ::MIDILightProto& _internal_playing() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_playing();

  public:
  // optional .MIDIButtonProto cue_in = 27;
  [[nodiscard]] bool has_cue_in() const;
  void clear_cue_in() ;
  [[nodiscard]] const ::MIDIButtonProto& cue_in() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_cue_in();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_cue_in();
  void set_allocated_cue_in(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_cue_in(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_cue_in();

  private:
  const ::MIDIButtonProto& _internal_cue_in() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_cue_in();

  public:
  // optional .MIDILightProto cue_in_enabled = 29;
  [[nodiscard]] bool has_cue_in_enabled() const;
  void clear_cue_in_enabled() ;
  [[nodiscard]] const ::MIDILightProto& cue_in_enabled() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_cue_in_enabled();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_cue_in_enabled();
  void set_allocated_cue_in_enabled(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_cue_in_enabled(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_cue_in_enabled();

  private:
  const ::MIDILightProto& _internal_cue_in_enabled() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_cue_in_enabled();

  public:
  // optional .MIDIButtonProto cue_out = 30;
  [[nodiscard]] bool has_cue_out() const;
  void clear_cue_out() ;
  [[nodiscard]] const ::MIDIButtonProto& cue_out() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_cue_out();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_cue_out();
  void set_allocated_cue_out(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_cue_out(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_cue_out();

  private:
  const ::MIDIButtonProto& _internal_cue_out() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_cue_out();

  public:
  // optional int32 num_controller_banks = 1 [default = 0];
  [[nodiscard]] bool has_num_controller_banks() const;
  void clear_num_controller_banks() ;
  [[nodiscard]] ::int32_t num_controller_banks() const;
  void set_num_controller_banks(::int32_t value);

  private:
  ::int32_t _internal_num_controller_banks() const;
  void _internal_set_num_controller_banks(::int32_t value);

  public:
  // optional int32 jog_bank = 17;
  [[nodiscard]] bool has_jog_bank() const;
  void clear_jog_bank() ;
  [[nodiscard]] ::int32_t jog_bank() const;
  void set_jog_bank(::int32_t value);

  private:
  ::int32_t _internal_jog_bank() const;
  void _internal_set_jog_bank(::int32_t value);

  public:
  // optional int32 preview_bank = 19;
  [[nodiscard]] bool has_preview_bank() const;
  void clear_preview_bank() ;
  [[nodiscard]] ::int32_t preview_bank() const;
  void set_preview_bank(::int32_t value);

  private:
  ::int32_t _internal_preview_bank() const;
  void _internal_set_preview_bank(::int32_t value);

  public:
  // optional int32 queue_bank = 22;
  [[nodiscard]] bool has_queue_bank() const;
  void clear_queue_bank() ;
  [[nodiscard]] ::int32_t queue_bank() const;
  void set_queue_bank(::int32_t value);

  private:
  ::int32_t _internal_queue_bank() const;
  void _internal_set_queue_bank(::int32_t value);

  public:
  // optional int32 play_bank = 25;
  [[nodiscard]] bool has_play_bank() const;
  void clear_play_bank() ;
  [[nodiscard]] ::int32_t play_bank() const;
  void set_play_bank(::int32_t value);

  private:
  ::int32_t _internal_play_bank() const;
  void _internal_set_play_bank(::int32_t value);

  public:
  // optional int32 cue_in_bank = 28;
  [[nodiscard]] bool has_cue_in_bank() const;
  void clear_cue_in_bank() ;
  [[nodiscard]] ::int32_t cue_in_bank() const;
  void set_cue_in_bank(::int32_t value);

  private:
  ::int32_t _internal_cue_in_bank() const;
  void _internal_set_cue_in_bank(::int32_t value);

  public:
  // optional int32 cue_out_bank = 31;
  [[nodiscard]] bool has_cue_out_bank() const;
  void clear_cue_out_bank() ;
  [[nodiscard]] ::int32_t cue_out_bank() const;
  void set_cue_out_bank(::int32_t value);

  private:
  ::int32_t _internal_cue_out_bank() const;
  void _internal_set_cue_out_bank(::int32_t value);

  public:
  // repeated .CameraMIDIMappingProto camera = 33;
  [[nodiscard]] int camera_size() const;
  private:
  int _internal_camera_size() const;

  public:
  void clear_camera() ;
  [[nodiscard]] const ::CameraMIDIMappingProto& camera(int index) const;
  [[nodiscard]] ::CameraMIDIMappingProto* PROTOBUF_NONNULL mutable_camera(int index);
  ::CameraMIDIMappingProto* PROTOBUF_NONNULL add_camera();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::CameraMIDIMappingProto>&
  camera() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::CameraMIDIMappingProto>* PROTOBUF_NONNULL
  mutable_camera();

  private:
  const ::google::protobuf::RepeatedPtrField<::CameraMIDIMappingProto>& _internal_camera() const;
  ::google::protobuf::RepeatedPtrField<::CameraMIDIMappingProto>* PROTOBUF_NONNULL _internal_mutable_camera();

  public:
  // optional .MIDILightProto cue_out_enabled = 32;
  [[nodiscard]] bool has_cue_out_enabled() const;
  void clear_cue_out_enabled() ;
  [[nodiscard]] const ::MIDILightProto& cue_out_enabled() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_cue_out_enabled();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_cue_out_enabled();
  void set_allocated_cue_out_enabled(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_cue_out_enabled(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_cue_out_enabled();

  private:
  const ::MIDILightProto& _internal_cue_out_enabled() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_cue_out_enabled();

  public:
  // optional .MIDIControllerProto master_speed = 34;
  [[nodiscard]] bool has_master_speed() const;
  void clear_master_speed() ;
  [[nodiscard]] const ::MIDIControllerProto& master_speed() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_master_speed();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_master_speed();
  void set_allocated_master_speed(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_master_speed(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_master_speed();

  private:
  const ::MIDIControllerProto& _internal_master_speed() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_master_speed();

  public:
  // optional .MIDIButtonProto toggle_lock = 36;
  [[nodiscard]] bool has_toggle_lock() const;
  void clear_toggle_lock() ;
  [[nodiscard]] const ::MIDIButtonProto& toggle_lock() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_toggle_lock();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_toggle_lock();
  void set_allocated_toggle_lock(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_toggle_lock(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_toggle_lock();

  private:
  const ::MIDIButtonProto& _internal_toggle_lock() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_toggle_lock();

  public:
  // optional .MIDILightProto locked = 38;
  [[nodiscard]] bool has_locked() const;
  void clear_locked() ;
  [[nodiscard]] const ::MIDILightProto& locked() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_locked();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_locked();
  void set_allocated_locked(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_locked(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_locked();

  private:
  const ::MIDILightProto& _internal_locked() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_locked();

  public:
  // optional .MIDILightProto locked_blinking = 39;
  [[nodiscard]] bool has_locked_blinking() const;
  void clear_locked_blinking() ;
  [[nodiscard]] const ::MIDILightProto& locked_blinking() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_locked_blinking();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_locked_blinking();
  void set_allocated_locked_blinking(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_locked_blinking(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_locked_blinking();

  private:
  const ::MIDILightProto& _internal_locked_blinking() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_locked_blinking();

  public:
  // optional .MIDILightProto play_ready = 40;
  [[nodiscard]] bool has_play_ready() const;
  void clear_play_ready() ;
  [[nodiscard]] const ::MIDILightProto& play_ready() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_play_ready();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_play_ready();
  void set_allocated_play_ready(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_play_ready(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_play_ready();

  private:
  const ::MIDILightProto& _internal_play_ready() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_play_ready();

  public:
  // optional .MIDILightProto preview_playing = 41;
  [[nodiscard]] bool has_preview_playing() const;
  void clear_preview_playing() ;
  [[nodiscard]] const ::MIDILightProto& preview_playing() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_preview_playing();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_preview_playing();
  void set_allocated_preview_playing(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_preview_playing(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_preview_playing();

  private:
  const ::MIDILightProto& _internal_preview_playing() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_preview_playing();

  public:
  // optional .MIDIControllerProto master_speed_light = 42;
  [[nodiscard]] bool has_master_speed_light() const;
  void clear_master_speed_light() ;
  [[nodiscard]] const ::MIDIControllerProto& master_speed_light() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_master_speed_light();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_master_speed_light();
  void set_allocated_master_speed_light(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_master_speed_light(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_master_speed_light();

  private:
  const ::MIDIControllerProto& _internal_master_speed_light() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_master_speed_light();

  public:
  // optional .MIDIButtonProto next = 45;
  [[nodiscard]] bool has_next() const;
  void clear_next() ;
  [[nodiscard]] const ::MIDIButtonProto& next() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_next();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_next();
  void set_allocated_next(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_next(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_next();

  private:
  const ::MIDIButtonProto& _internal_next() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_next();

  public:
  // optional .MIDILightProto next_ready = 47;
  [[nodiscard]] bool has_next_ready() const;
  void clear_next_ready() ;
  [[nodiscard]] const ::MIDILightProto& next_ready() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_next_ready();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_next_ready();
  void set_allocated_next_ready(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_next_ready(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_next_ready();

  private:
  const ::MIDILightProto& _internal_next_ready() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_next_ready();

  public:
  // optional int32 master_speed_bank = 35;
  [[nodiscard]] bool has_master_speed_bank() const;
  void clear_master_speed_bank() ;
  [[nodiscard]] ::int32_t master_speed_bank() const;
  void set_master_speed_bank(::int32_t value);

  private:
  ::int32_t _internal_master_speed_bank() const;
  void _internal_set_master_speed_bank(::int32_t value);

  public:
  // optional int32 toggle_lock_bank = 37;
  [[nodiscard]] bool has_toggle_lock_bank() const;
  void clear_toggle_lock_bank() ;
  [[nodiscard]] ::int32_t toggle_lock_bank() const;
  void set_toggle_lock_bank(::int32_t value);

  private:
  ::int32_t _internal_toggle_lock_bank() const;
  void _internal_set_toggle_lock_bank(::int32_t value);

  public:
  // optional int32 master_speed_light_min = 43;
  [[nodiscard]] bool has_master_speed_light_min() const;
  void clear_master_speed_light_min() ;
  [[nodiscard]] ::int32_t master_speed_light_min() const;
  void set_master_speed_light_min(::int32_t value);

  private:
  ::int32_t _internal_master_speed_light_min() const;
  void _internal_set_master_speed_light_min(::int32_t value);

  public:
  // optional int32 next_button_bank = 46;
  [[nodiscard]] bool has_next_button_bank() const;
  void clear_next_button_bank() ;
  [[nodiscard]] ::int32_t next_button_bank() const;
  void set_next_button_bank(::int32_t value);

  private:
  ::int32_t _internal_next_button_bank() const;
  void _internal_set_next_button_bank(::int32_t value);

  public:
  // optional int32 master_speed_light_max = 44 [default = 127];
  [[nodiscard]] bool has_master_speed_light_max() const;
  void clear_master_speed_light_max() ;
  [[nodiscard]] ::int32_t master_speed_light_max() const;
  void set_master_speed_light_max(::int32_t value);

  private:
  ::int32_t _internal_master_speed_light_max() const;
  void _internal_set_master_speed_light_max(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:MIDIMappingProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<5, 45,
                          33, 0,
                          7>;
  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 MIDIMappingProto& from_msg);
    ::google::protobuf::internal::HasBits<2> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE prev_bank_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE next_bank_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE select_bank_1_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE select_bank_2_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE select_bank_3_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE select_bank_4_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE select_bank_5_;
    ::MIDILightProto* PROTOBUF_NULLABLE bank_1_is_selected_;
    ::MIDILightProto* PROTOBUF_NULLABLE bank_2_is_selected_;
    ::MIDILightProto* PROTOBUF_NULLABLE bank_3_is_selected_;
    ::MIDILightProto* PROTOBUF_NULLABLE bank_4_is_selected_;
    ::MIDILightProto* PROTOBUF_NULLABLE bank_5_is_selected_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE jog_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE preview_;
    ::MIDILightProto* PROTOBUF_NULLABLE preview_ready_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE queue_;
    ::MIDILightProto* PROTOBUF_NULLABLE queue_enabled_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE play_;
    ::MIDILightProto* PROTOBUF_NULLABLE playing_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE cue_in_;
    ::MIDILightProto* PROTOBUF_NULLABLE cue_in_enabled_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE cue_out_;
    ::int32_t num_controller_banks_;
    ::int32_t jog_bank_;
    ::int32_t preview_bank_;
    ::int32_t queue_bank_;
    ::int32_t play_bank_;
    ::int32_t cue_in_bank_;
    ::int32_t cue_out_bank_;
    ::google::protobuf::RepeatedPtrField< ::CameraMIDIMappingProto > camera_;
    ::MIDILightProto* PROTOBUF_NULLABLE cue_out_enabled_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE master_speed_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE toggle_lock_;
    ::MIDILightProto* PROTOBUF_NULLABLE locked_;
    ::MIDILightProto* PROTOBUF_NULLABLE locked_blinking_;
    ::MIDILightProto* PROTOBUF_NULLABLE play_ready_;
    ::MIDILightProto* PROTOBUF_NULLABLE preview_playing_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE master_speed_light_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE next_;
    ::MIDILightProto* PROTOBUF_NULLABLE next_ready_;
    ::int32_t master_speed_bank_;
    ::int32_t toggle_lock_bank_;
    ::int32_t master_speed_light_min_;
    ::int32_t next_button_bank_;
    ::int32_t master_speed_light_max_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_futatabi_5fmidi_5fmapping_2eproto;
};

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




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


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

// CameraMIDIMappingProto

// optional .MIDIButtonProto button = 1;
inline bool CameraMIDIMappingProto::has_button() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.button_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& CameraMIDIMappingProto::_internal_button() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.button_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& CameraMIDIMappingProto::button() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:CameraMIDIMappingProto.button)
  return _internal_button();
}
inline void CameraMIDIMappingProto::unsafe_arena_set_allocated_button(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.button_);
  }
  _impl_.button_ = reinterpret_cast<::MIDIButtonProto*>(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:CameraMIDIMappingProto.button)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE CameraMIDIMappingProto::release_button() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::MIDIButtonProto* released = _impl_.button_;
  _impl_.button_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE CameraMIDIMappingProto::unsafe_arena_release_button() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:CameraMIDIMappingProto.button)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::MIDIButtonProto* temp = _impl_.button_;
  _impl_.button_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL CameraMIDIMappingProto::_internal_mutable_button() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.button_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.button_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.button_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL CameraMIDIMappingProto::mutable_button()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::MIDIButtonProto* _msg = _internal_mutable_button();
  // @@protoc_insertion_point(field_mutable:CameraMIDIMappingProto.button)
  return _msg;
}
inline void CameraMIDIMappingProto::set_allocated_button(::MIDIButtonProto* 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_.button_);
  }

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

  _impl_.button_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:CameraMIDIMappingProto.button)
}

// optional int32 bank = 2;
inline bool CameraMIDIMappingProto::has_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void CameraMIDIMappingProto::clear_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::int32_t CameraMIDIMappingProto::bank() const {
  // @@protoc_insertion_point(field_get:CameraMIDIMappingProto.bank)
  return _internal_bank();
}
inline void CameraMIDIMappingProto::set_bank(::int32_t value) {
  _internal_set_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:CameraMIDIMappingProto.bank)
}
inline ::int32_t CameraMIDIMappingProto::_internal_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.bank_;
}
inline void CameraMIDIMappingProto::_internal_set_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bank_ = value;
}

// optional .MIDILightProto is_current = 3;
inline bool CameraMIDIMappingProto::has_is_current() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.is_current_ != nullptr);
  return value;
}
inline const ::MIDILightProto& CameraMIDIMappingProto::_internal_is_current() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.is_current_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& CameraMIDIMappingProto::is_current() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:CameraMIDIMappingProto.is_current)
  return _internal_is_current();
}
inline void CameraMIDIMappingProto::unsafe_arena_set_allocated_is_current(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.is_current_);
  }
  _impl_.is_current_ = reinterpret_cast<::MIDILightProto*>(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:CameraMIDIMappingProto.is_current)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE CameraMIDIMappingProto::release_is_current() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::MIDILightProto* released = _impl_.is_current_;
  _impl_.is_current_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE CameraMIDIMappingProto::unsafe_arena_release_is_current() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:CameraMIDIMappingProto.is_current)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::MIDILightProto* temp = _impl_.is_current_;
  _impl_.is_current_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL CameraMIDIMappingProto::_internal_mutable_is_current() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.is_current_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.is_current_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.is_current_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL CameraMIDIMappingProto::mutable_is_current()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::MIDILightProto* _msg = _internal_mutable_is_current();
  // @@protoc_insertion_point(field_mutable:CameraMIDIMappingProto.is_current)
  return _msg;
}
inline void CameraMIDIMappingProto::set_allocated_is_current(::MIDILightProto* 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_.is_current_);
  }

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

  _impl_.is_current_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:CameraMIDIMappingProto.is_current)
}

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

// MIDIMappingProto

// optional int32 num_controller_banks = 1 [default = 0];
inline bool MIDIMappingProto::has_num_controller_banks() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00400000U);
  return value;
}
inline void MIDIMappingProto::clear_num_controller_banks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_controller_banks_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
}
inline ::int32_t MIDIMappingProto::num_controller_banks() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.num_controller_banks)
  return _internal_num_controller_banks();
}
inline void MIDIMappingProto::set_num_controller_banks(::int32_t value) {
  _internal_set_num_controller_banks(value);
  SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.num_controller_banks)
}
inline ::int32_t MIDIMappingProto::_internal_num_controller_banks() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_controller_banks_;
}
inline void MIDIMappingProto::_internal_set_num_controller_banks(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_controller_banks_ = value;
}

// optional .MIDIButtonProto prev_bank = 2;
inline bool MIDIMappingProto::has_prev_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.prev_bank_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_prev_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.prev_bank_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::prev_bank() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.prev_bank)
  return _internal_prev_bank();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_prev_bank(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.prev_bank_);
  }
  _impl_.prev_bank_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingProto.prev_bank)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_prev_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::MIDIButtonProto* released = _impl_.prev_bank_;
  _impl_.prev_bank_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_prev_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.prev_bank)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::MIDIButtonProto* temp = _impl_.prev_bank_;
  _impl_.prev_bank_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_prev_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.prev_bank_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.prev_bank_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.prev_bank_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_prev_bank()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::MIDIButtonProto* _msg = _internal_mutable_prev_bank();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.prev_bank)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_prev_bank(::MIDIButtonProto* 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_.prev_bank_);
  }

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

  _impl_.prev_bank_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.prev_bank)
}

// optional .MIDIButtonProto next_bank = 3;
inline bool MIDIMappingProto::has_next_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.next_bank_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_next_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.next_bank_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::next_bank() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.next_bank)
  return _internal_next_bank();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_next_bank(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.next_bank_);
  }
  _impl_.next_bank_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingProto.next_bank)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_next_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::MIDIButtonProto* released = _impl_.next_bank_;
  _impl_.next_bank_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_next_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.next_bank)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::MIDIButtonProto* temp = _impl_.next_bank_;
  _impl_.next_bank_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_next_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.next_bank_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.next_bank_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.next_bank_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_next_bank()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::MIDIButtonProto* _msg = _internal_mutable_next_bank();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.next_bank)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_next_bank(::MIDIButtonProto* 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_.next_bank_);
  }

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

  _impl_.next_bank_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.next_bank)
}

// optional .MIDIButtonProto select_bank_1 = 4;
inline bool MIDIMappingProto::has_select_bank_1() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.select_bank_1_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_select_bank_1() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.select_bank_1_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::select_bank_1() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.select_bank_1)
  return _internal_select_bank_1();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_select_bank_1(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.select_bank_1_);
  }
  _impl_.select_bank_1_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingProto.select_bank_1)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_select_bank_1() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::MIDIButtonProto* released = _impl_.select_bank_1_;
  _impl_.select_bank_1_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_select_bank_1() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.select_bank_1)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::MIDIButtonProto* temp = _impl_.select_bank_1_;
  _impl_.select_bank_1_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_select_bank_1() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.select_bank_1_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.select_bank_1_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.select_bank_1_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_select_bank_1()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::MIDIButtonProto* _msg = _internal_mutable_select_bank_1();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.select_bank_1)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_select_bank_1(::MIDIButtonProto* 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_.select_bank_1_);
  }

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

  _impl_.select_bank_1_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.select_bank_1)
}

// optional .MIDIButtonProto select_bank_2 = 5;
inline bool MIDIMappingProto::has_select_bank_2() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.select_bank_2_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_select_bank_2() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.select_bank_2_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::select_bank_2() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.select_bank_2)
  return _internal_select_bank_2();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_select_bank_2(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.select_bank_2_);
  }
  _impl_.select_bank_2_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingProto.select_bank_2)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_select_bank_2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::MIDIButtonProto* released = _impl_.select_bank_2_;
  _impl_.select_bank_2_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_select_bank_2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.select_bank_2)

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::MIDIButtonProto* temp = _impl_.select_bank_2_;
  _impl_.select_bank_2_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_select_bank_2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.select_bank_2_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.select_bank_2_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.select_bank_2_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_select_bank_2()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::MIDIButtonProto* _msg = _internal_mutable_select_bank_2();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.select_bank_2)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_select_bank_2(::MIDIButtonProto* 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_.select_bank_2_);
  }

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

  _impl_.select_bank_2_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.select_bank_2)
}

// optional .MIDIButtonProto select_bank_3 = 6;
inline bool MIDIMappingProto::has_select_bank_3() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.select_bank_3_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_select_bank_3() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.select_bank_3_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::select_bank_3() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.select_bank_3)
  return _internal_select_bank_3();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_select_bank_3(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.select_bank_3_);
  }
  _impl_.select_bank_3_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingProto.select_bank_3)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_select_bank_3() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::MIDIButtonProto* released = _impl_.select_bank_3_;
  _impl_.select_bank_3_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_select_bank_3() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.select_bank_3)

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::MIDIButtonProto* temp = _impl_.select_bank_3_;
  _impl_.select_bank_3_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_select_bank_3() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.select_bank_3_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.select_bank_3_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.select_bank_3_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_select_bank_3()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::MIDIButtonProto* _msg = _internal_mutable_select_bank_3();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.select_bank_3)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_select_bank_3(::MIDIButtonProto* 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_.select_bank_3_);
  }

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

  _impl_.select_bank_3_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.select_bank_3)
}

// optional .MIDIButtonProto select_bank_4 = 7;
inline bool MIDIMappingProto::has_select_bank_4() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  PROTOBUF_ASSUME(!value || _impl_.select_bank_4_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_select_bank_4() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.select_bank_4_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::select_bank_4() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.select_bank_4)
  return _internal_select_bank_4();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_select_bank_4(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.select_bank_4_);
  }
  _impl_.select_bank_4_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingProto.select_bank_4)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_select_bank_4() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::MIDIButtonProto* released = _impl_.select_bank_4_;
  _impl_.select_bank_4_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_select_bank_4() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.select_bank_4)

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::MIDIButtonProto* temp = _impl_.select_bank_4_;
  _impl_.select_bank_4_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_select_bank_4() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.select_bank_4_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.select_bank_4_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.select_bank_4_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_select_bank_4()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::MIDIButtonProto* _msg = _internal_mutable_select_bank_4();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.select_bank_4)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_select_bank_4(::MIDIButtonProto* 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_.select_bank_4_);
  }

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

  _impl_.select_bank_4_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.select_bank_4)
}

// optional .MIDIButtonProto select_bank_5 = 8;
inline bool MIDIMappingProto::has_select_bank_5() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  PROTOBUF_ASSUME(!value || _impl_.select_bank_5_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_select_bank_5() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.select_bank_5_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::select_bank_5() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.select_bank_5)
  return _internal_select_bank_5();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_select_bank_5(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.select_bank_5_);
  }
  _impl_.select_bank_5_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingProto.select_bank_5)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_select_bank_5() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::MIDIButtonProto* released = _impl_.select_bank_5_;
  _impl_.select_bank_5_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_select_bank_5() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.select_bank_5)

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::MIDIButtonProto* temp = _impl_.select_bank_5_;
  _impl_.select_bank_5_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_select_bank_5() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.select_bank_5_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.select_bank_5_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.select_bank_5_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_select_bank_5()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::MIDIButtonProto* _msg = _internal_mutable_select_bank_5();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.select_bank_5)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_select_bank_5(::MIDIButtonProto* 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_.select_bank_5_);
  }

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

  _impl_.select_bank_5_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.select_bank_5)
}

// optional .MIDILightProto bank_1_is_selected = 9;
inline bool MIDIMappingProto::has_bank_1_is_selected() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  PROTOBUF_ASSUME(!value || _impl_.bank_1_is_selected_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_bank_1_is_selected() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.bank_1_is_selected_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::bank_1_is_selected() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.bank_1_is_selected)
  return _internal_bank_1_is_selected();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_bank_1_is_selected(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.bank_1_is_selected_);
  }
  _impl_.bank_1_is_selected_ = reinterpret_cast<::MIDILightProto*>(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:MIDIMappingProto.bank_1_is_selected)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_bank_1_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::MIDILightProto* released = _impl_.bank_1_is_selected_;
  _impl_.bank_1_is_selected_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_bank_1_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.bank_1_is_selected)

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::MIDILightProto* temp = _impl_.bank_1_is_selected_;
  _impl_.bank_1_is_selected_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_bank_1_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.bank_1_is_selected_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.bank_1_is_selected_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.bank_1_is_selected_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_bank_1_is_selected()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::MIDILightProto* _msg = _internal_mutable_bank_1_is_selected();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.bank_1_is_selected)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_bank_1_is_selected(::MIDILightProto* 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_.bank_1_is_selected_);
  }

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

  _impl_.bank_1_is_selected_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.bank_1_is_selected)
}

// optional .MIDILightProto bank_2_is_selected = 10;
inline bool MIDIMappingProto::has_bank_2_is_selected() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.bank_2_is_selected_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_bank_2_is_selected() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.bank_2_is_selected_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::bank_2_is_selected() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.bank_2_is_selected)
  return _internal_bank_2_is_selected();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_bank_2_is_selected(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.bank_2_is_selected_);
  }
  _impl_.bank_2_is_selected_ = reinterpret_cast<::MIDILightProto*>(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:MIDIMappingProto.bank_2_is_selected)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_bank_2_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::MIDILightProto* released = _impl_.bank_2_is_selected_;
  _impl_.bank_2_is_selected_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_bank_2_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.bank_2_is_selected)

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::MIDILightProto* temp = _impl_.bank_2_is_selected_;
  _impl_.bank_2_is_selected_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_bank_2_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.bank_2_is_selected_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.bank_2_is_selected_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.bank_2_is_selected_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_bank_2_is_selected()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::MIDILightProto* _msg = _internal_mutable_bank_2_is_selected();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.bank_2_is_selected)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_bank_2_is_selected(::MIDILightProto* 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_.bank_2_is_selected_);
  }

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

  _impl_.bank_2_is_selected_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.bank_2_is_selected)
}

// optional .MIDILightProto bank_3_is_selected = 11;
inline bool MIDIMappingProto::has_bank_3_is_selected() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  PROTOBUF_ASSUME(!value || _impl_.bank_3_is_selected_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_bank_3_is_selected() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.bank_3_is_selected_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::bank_3_is_selected() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.bank_3_is_selected)
  return _internal_bank_3_is_selected();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_bank_3_is_selected(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.bank_3_is_selected_);
  }
  _impl_.bank_3_is_selected_ = reinterpret_cast<::MIDILightProto*>(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:MIDIMappingProto.bank_3_is_selected)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_bank_3_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::MIDILightProto* released = _impl_.bank_3_is_selected_;
  _impl_.bank_3_is_selected_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_bank_3_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.bank_3_is_selected)

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::MIDILightProto* temp = _impl_.bank_3_is_selected_;
  _impl_.bank_3_is_selected_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_bank_3_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.bank_3_is_selected_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.bank_3_is_selected_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.bank_3_is_selected_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_bank_3_is_selected()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::MIDILightProto* _msg = _internal_mutable_bank_3_is_selected();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.bank_3_is_selected)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_bank_3_is_selected(::MIDILightProto* 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_.bank_3_is_selected_);
  }

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

  _impl_.bank_3_is_selected_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.bank_3_is_selected)
}

// optional .MIDILightProto bank_4_is_selected = 12;
inline bool MIDIMappingProto::has_bank_4_is_selected() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  PROTOBUF_ASSUME(!value || _impl_.bank_4_is_selected_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_bank_4_is_selected() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.bank_4_is_selected_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::bank_4_is_selected() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.bank_4_is_selected)
  return _internal_bank_4_is_selected();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_bank_4_is_selected(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.bank_4_is_selected_);
  }
  _impl_.bank_4_is_selected_ = reinterpret_cast<::MIDILightProto*>(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:MIDIMappingProto.bank_4_is_selected)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_bank_4_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::MIDILightProto* released = _impl_.bank_4_is_selected_;
  _impl_.bank_4_is_selected_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_bank_4_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.bank_4_is_selected)

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::MIDILightProto* temp = _impl_.bank_4_is_selected_;
  _impl_.bank_4_is_selected_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_bank_4_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.bank_4_is_selected_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.bank_4_is_selected_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.bank_4_is_selected_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_bank_4_is_selected()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::MIDILightProto* _msg = _internal_mutable_bank_4_is_selected();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.bank_4_is_selected)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_bank_4_is_selected(::MIDILightProto* 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_.bank_4_is_selected_);
  }

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

  _impl_.bank_4_is_selected_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.bank_4_is_selected)
}

// optional .MIDILightProto bank_5_is_selected = 13;
inline bool MIDIMappingProto::has_bank_5_is_selected() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  PROTOBUF_ASSUME(!value || _impl_.bank_5_is_selected_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_bank_5_is_selected() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.bank_5_is_selected_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::bank_5_is_selected() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.bank_5_is_selected)
  return _internal_bank_5_is_selected();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_bank_5_is_selected(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.bank_5_is_selected_);
  }
  _impl_.bank_5_is_selected_ = reinterpret_cast<::MIDILightProto*>(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:MIDIMappingProto.bank_5_is_selected)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_bank_5_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::MIDILightProto* released = _impl_.bank_5_is_selected_;
  _impl_.bank_5_is_selected_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_bank_5_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.bank_5_is_selected)

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::MIDILightProto* temp = _impl_.bank_5_is_selected_;
  _impl_.bank_5_is_selected_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_bank_5_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.bank_5_is_selected_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.bank_5_is_selected_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.bank_5_is_selected_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_bank_5_is_selected()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::MIDILightProto* _msg = _internal_mutable_bank_5_is_selected();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.bank_5_is_selected)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_bank_5_is_selected(::MIDILightProto* 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_.bank_5_is_selected_);
  }

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

  _impl_.bank_5_is_selected_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.bank_5_is_selected)
}

// optional .MIDIControllerProto jog = 16;
inline bool MIDIMappingProto::has_jog() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  PROTOBUF_ASSUME(!value || _impl_.jog_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingProto::_internal_jog() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.jog_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingProto::jog() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.jog)
  return _internal_jog();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_jog(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.jog_);
  }
  _impl_.jog_ = reinterpret_cast<::MIDIControllerProto*>(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:MIDIMappingProto.jog)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingProto::release_jog() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::MIDIControllerProto* released = _impl_.jog_;
  _impl_.jog_ = 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 ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_jog() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.jog)

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::MIDIControllerProto* temp = _impl_.jog_;
  _impl_.jog_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_jog() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.jog_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.jog_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.jog_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_jog()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::MIDIControllerProto* _msg = _internal_mutable_jog();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.jog)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_jog(::MIDIControllerProto* 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_.jog_);
  }

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

  _impl_.jog_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.jog)
}

// optional int32 jog_bank = 17;
inline bool MIDIMappingProto::has_jog_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00800000U);
  return value;
}
inline void MIDIMappingProto::clear_jog_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.jog_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
}
inline ::int32_t MIDIMappingProto::jog_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.jog_bank)
  return _internal_jog_bank();
}
inline void MIDIMappingProto::set_jog_bank(::int32_t value) {
  _internal_set_jog_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.jog_bank)
}
inline ::int32_t MIDIMappingProto::_internal_jog_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.jog_bank_;
}
inline void MIDIMappingProto::_internal_set_jog_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.jog_bank_ = value;
}

// optional .MIDIControllerProto master_speed = 34;
inline bool MIDIMappingProto::has_master_speed() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x80000000U);
  PROTOBUF_ASSUME(!value || _impl_.master_speed_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingProto::_internal_master_speed() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.master_speed_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingProto::master_speed() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.master_speed)
  return _internal_master_speed();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_master_speed(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.master_speed_);
  }
  _impl_.master_speed_ = reinterpret_cast<::MIDIControllerProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.master_speed)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingProto::release_master_speed() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  ::MIDIControllerProto* released = _impl_.master_speed_;
  _impl_.master_speed_ = 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 ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_master_speed() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.master_speed)

  ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  ::MIDIControllerProto* temp = _impl_.master_speed_;
  _impl_.master_speed_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_master_speed() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.master_speed_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.master_speed_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.master_speed_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_master_speed()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  ::MIDIControllerProto* _msg = _internal_mutable_master_speed();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.master_speed)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_master_speed(::MIDIControllerProto* 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_.master_speed_);
  }

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

  _impl_.master_speed_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.master_speed)
}

// optional int32 master_speed_bank = 35;
inline bool MIDIMappingProto::has_master_speed_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000100U);
  return value;
}
inline void MIDIMappingProto::clear_master_speed_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.master_speed_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[1], 0x00000100U);
}
inline ::int32_t MIDIMappingProto::master_speed_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.master_speed_bank)
  return _internal_master_speed_bank();
}
inline void MIDIMappingProto::set_master_speed_bank(::int32_t value) {
  _internal_set_master_speed_bank(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000100U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.master_speed_bank)
}
inline ::int32_t MIDIMappingProto::_internal_master_speed_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.master_speed_bank_;
}
inline void MIDIMappingProto::_internal_set_master_speed_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.master_speed_bank_ = value;
}

// optional .MIDIControllerProto master_speed_light = 42;
inline bool MIDIMappingProto::has_master_speed_light() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000020U);
  PROTOBUF_ASSUME(!value || _impl_.master_speed_light_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingProto::_internal_master_speed_light() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.master_speed_light_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingProto::master_speed_light() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.master_speed_light)
  return _internal_master_speed_light();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_master_speed_light(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.master_speed_light_);
  }
  _impl_.master_speed_light_ = reinterpret_cast<::MIDIControllerProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000020U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.master_speed_light)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingProto::release_master_speed_light() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000020U);
  ::MIDIControllerProto* released = _impl_.master_speed_light_;
  _impl_.master_speed_light_ = 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 ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_master_speed_light() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.master_speed_light)

  ClearHasBit(_impl_._has_bits_[1], 0x00000020U);
  ::MIDIControllerProto* temp = _impl_.master_speed_light_;
  _impl_.master_speed_light_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_master_speed_light() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.master_speed_light_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.master_speed_light_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.master_speed_light_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_master_speed_light()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000020U);
  ::MIDIControllerProto* _msg = _internal_mutable_master_speed_light();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.master_speed_light)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_master_speed_light(::MIDIControllerProto* 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_.master_speed_light_);
  }

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

  _impl_.master_speed_light_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.master_speed_light)
}

// optional int32 master_speed_light_min = 43;
inline bool MIDIMappingProto::has_master_speed_light_min() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000400U);
  return value;
}
inline void MIDIMappingProto::clear_master_speed_light_min() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.master_speed_light_min_ = 0;
  ClearHasBit(_impl_._has_bits_[1], 0x00000400U);
}
inline ::int32_t MIDIMappingProto::master_speed_light_min() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.master_speed_light_min)
  return _internal_master_speed_light_min();
}
inline void MIDIMappingProto::set_master_speed_light_min(::int32_t value) {
  _internal_set_master_speed_light_min(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000400U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.master_speed_light_min)
}
inline ::int32_t MIDIMappingProto::_internal_master_speed_light_min() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.master_speed_light_min_;
}
inline void MIDIMappingProto::_internal_set_master_speed_light_min(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.master_speed_light_min_ = value;
}

// optional int32 master_speed_light_max = 44 [default = 127];
inline bool MIDIMappingProto::has_master_speed_light_max() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00001000U);
  return value;
}
inline void MIDIMappingProto::clear_master_speed_light_max() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.master_speed_light_max_ = 127;
  ClearHasBit(_impl_._has_bits_[1], 0x00001000U);
}
inline ::int32_t MIDIMappingProto::master_speed_light_max() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.master_speed_light_max)
  return _internal_master_speed_light_max();
}
inline void MIDIMappingProto::set_master_speed_light_max(::int32_t value) {
  _internal_set_master_speed_light_max(value);
  SetHasBit(_impl_._has_bits_[1], 0x00001000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.master_speed_light_max)
}
inline ::int32_t MIDIMappingProto::_internal_master_speed_light_max() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.master_speed_light_max_;
}
inline void MIDIMappingProto::_internal_set_master_speed_light_max(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.master_speed_light_max_ = value;
}

// optional .MIDIButtonProto preview = 18;
inline bool MIDIMappingProto::has_preview() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  PROTOBUF_ASSUME(!value || _impl_.preview_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_preview() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.preview_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::preview() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.preview)
  return _internal_preview();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_preview(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.preview_);
  }
  _impl_.preview_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingProto.preview)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_preview() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::MIDIButtonProto* released = _impl_.preview_;
  _impl_.preview_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_preview() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.preview)

  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::MIDIButtonProto* temp = _impl_.preview_;
  _impl_.preview_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_preview() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.preview_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.preview_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.preview_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_preview()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::MIDIButtonProto* _msg = _internal_mutable_preview();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.preview)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_preview(::MIDIButtonProto* 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_.preview_);
  }

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

  _impl_.preview_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.preview)
}

// optional int32 preview_bank = 19;
inline bool MIDIMappingProto::has_preview_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x01000000U);
  return value;
}
inline void MIDIMappingProto::clear_preview_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.preview_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
}
inline ::int32_t MIDIMappingProto::preview_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.preview_bank)
  return _internal_preview_bank();
}
inline void MIDIMappingProto::set_preview_bank(::int32_t value) {
  _internal_set_preview_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.preview_bank)
}
inline ::int32_t MIDIMappingProto::_internal_preview_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.preview_bank_;
}
inline void MIDIMappingProto::_internal_set_preview_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.preview_bank_ = value;
}

// optional .MIDILightProto preview_playing = 41;
inline bool MIDIMappingProto::has_preview_playing() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.preview_playing_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_preview_playing() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.preview_playing_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::preview_playing() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.preview_playing)
  return _internal_preview_playing();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_preview_playing(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.preview_playing_);
  }
  _impl_.preview_playing_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000010U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.preview_playing)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_preview_playing() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000010U);
  ::MIDILightProto* released = _impl_.preview_playing_;
  _impl_.preview_playing_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_preview_playing() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.preview_playing)

  ClearHasBit(_impl_._has_bits_[1], 0x00000010U);
  ::MIDILightProto* temp = _impl_.preview_playing_;
  _impl_.preview_playing_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_preview_playing() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.preview_playing_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.preview_playing_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.preview_playing_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_preview_playing()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000010U);
  ::MIDILightProto* _msg = _internal_mutable_preview_playing();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.preview_playing)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_preview_playing(::MIDILightProto* 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_.preview_playing_);
  }

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

  _impl_.preview_playing_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.preview_playing)
}

// optional .MIDILightProto preview_ready = 20;
inline bool MIDIMappingProto::has_preview_ready() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  PROTOBUF_ASSUME(!value || _impl_.preview_ready_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_preview_ready() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.preview_ready_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::preview_ready() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.preview_ready)
  return _internal_preview_ready();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_preview_ready(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.preview_ready_);
  }
  _impl_.preview_ready_ = reinterpret_cast<::MIDILightProto*>(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:MIDIMappingProto.preview_ready)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_preview_ready() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::MIDILightProto* released = _impl_.preview_ready_;
  _impl_.preview_ready_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_preview_ready() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.preview_ready)

  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::MIDILightProto* temp = _impl_.preview_ready_;
  _impl_.preview_ready_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_preview_ready() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.preview_ready_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.preview_ready_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.preview_ready_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_preview_ready()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::MIDILightProto* _msg = _internal_mutable_preview_ready();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.preview_ready)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_preview_ready(::MIDILightProto* 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_.preview_ready_);
  }

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

  _impl_.preview_ready_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.preview_ready)
}

// optional .MIDIButtonProto queue = 21;
inline bool MIDIMappingProto::has_queue() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00008000U);
  PROTOBUF_ASSUME(!value || _impl_.queue_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_queue() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.queue_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::queue() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.queue)
  return _internal_queue();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_queue(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.queue_);
  }
  _impl_.queue_ = reinterpret_cast<::MIDIButtonProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.queue)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_queue() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  ::MIDIButtonProto* released = _impl_.queue_;
  _impl_.queue_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_queue() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.queue)

  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  ::MIDIButtonProto* temp = _impl_.queue_;
  _impl_.queue_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_queue() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.queue_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.queue_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.queue_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_queue()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  ::MIDIButtonProto* _msg = _internal_mutable_queue();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.queue)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_queue(::MIDIButtonProto* 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_.queue_);
  }

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

  _impl_.queue_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.queue)
}

// optional int32 queue_bank = 22;
inline bool MIDIMappingProto::has_queue_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x02000000U);
  return value;
}
inline void MIDIMappingProto::clear_queue_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.queue_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x02000000U);
}
inline ::int32_t MIDIMappingProto::queue_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.queue_bank)
  return _internal_queue_bank();
}
inline void MIDIMappingProto::set_queue_bank(::int32_t value) {
  _internal_set_queue_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x02000000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.queue_bank)
}
inline ::int32_t MIDIMappingProto::_internal_queue_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.queue_bank_;
}
inline void MIDIMappingProto::_internal_set_queue_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.queue_bank_ = value;
}

// optional .MIDILightProto queue_enabled = 23;
inline bool MIDIMappingProto::has_queue_enabled() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00010000U);
  PROTOBUF_ASSUME(!value || _impl_.queue_enabled_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_queue_enabled() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.queue_enabled_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::queue_enabled() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.queue_enabled)
  return _internal_queue_enabled();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_queue_enabled(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.queue_enabled_);
  }
  _impl_.queue_enabled_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.queue_enabled)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_queue_enabled() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  ::MIDILightProto* released = _impl_.queue_enabled_;
  _impl_.queue_enabled_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_queue_enabled() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.queue_enabled)

  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  ::MIDILightProto* temp = _impl_.queue_enabled_;
  _impl_.queue_enabled_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_queue_enabled() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.queue_enabled_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.queue_enabled_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.queue_enabled_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_queue_enabled()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  ::MIDILightProto* _msg = _internal_mutable_queue_enabled();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.queue_enabled)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_queue_enabled(::MIDILightProto* 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_.queue_enabled_);
  }

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

  _impl_.queue_enabled_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.queue_enabled)
}

// optional .MIDIButtonProto play = 24;
inline bool MIDIMappingProto::has_play() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00020000U);
  PROTOBUF_ASSUME(!value || _impl_.play_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_play() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.play_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::play() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.play)
  return _internal_play();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_play(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.play_);
  }
  _impl_.play_ = reinterpret_cast<::MIDIButtonProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.play)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_play() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
  ::MIDIButtonProto* released = _impl_.play_;
  _impl_.play_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_play() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.play)

  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
  ::MIDIButtonProto* temp = _impl_.play_;
  _impl_.play_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_play() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.play_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.play_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.play_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_play()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  ::MIDIButtonProto* _msg = _internal_mutable_play();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.play)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_play(::MIDIButtonProto* 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_.play_);
  }

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

  _impl_.play_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.play)
}

// optional int32 play_bank = 25;
inline bool MIDIMappingProto::has_play_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x04000000U);
  return value;
}
inline void MIDIMappingProto::clear_play_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.play_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x04000000U);
}
inline ::int32_t MIDIMappingProto::play_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.play_bank)
  return _internal_play_bank();
}
inline void MIDIMappingProto::set_play_bank(::int32_t value) {
  _internal_set_play_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x04000000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.play_bank)
}
inline ::int32_t MIDIMappingProto::_internal_play_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.play_bank_;
}
inline void MIDIMappingProto::_internal_set_play_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.play_bank_ = value;
}

// optional .MIDILightProto playing = 26;
inline bool MIDIMappingProto::has_playing() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00040000U);
  PROTOBUF_ASSUME(!value || _impl_.playing_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_playing() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.playing_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::playing() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.playing)
  return _internal_playing();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_playing(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.playing_);
  }
  _impl_.playing_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.playing)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_playing() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
  ::MIDILightProto* released = _impl_.playing_;
  _impl_.playing_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_playing() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.playing)

  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
  ::MIDILightProto* temp = _impl_.playing_;
  _impl_.playing_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_playing() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.playing_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.playing_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.playing_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_playing()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  ::MIDILightProto* _msg = _internal_mutable_playing();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.playing)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_playing(::MIDILightProto* 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_.playing_);
  }

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

  _impl_.playing_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.playing)
}

// optional .MIDILightProto play_ready = 40;
inline bool MIDIMappingProto::has_play_ready() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.play_ready_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_play_ready() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.play_ready_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::play_ready() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.play_ready)
  return _internal_play_ready();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_play_ready(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.play_ready_);
  }
  _impl_.play_ready_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000008U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.play_ready)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_play_ready() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000008U);
  ::MIDILightProto* released = _impl_.play_ready_;
  _impl_.play_ready_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_play_ready() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.play_ready)

  ClearHasBit(_impl_._has_bits_[1], 0x00000008U);
  ::MIDILightProto* temp = _impl_.play_ready_;
  _impl_.play_ready_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_play_ready() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.play_ready_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.play_ready_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.play_ready_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_play_ready()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000008U);
  ::MIDILightProto* _msg = _internal_mutable_play_ready();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.play_ready)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_play_ready(::MIDILightProto* 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_.play_ready_);
  }

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

  _impl_.play_ready_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.play_ready)
}

// optional .MIDIButtonProto next = 45;
inline bool MIDIMappingProto::has_next() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000040U);
  PROTOBUF_ASSUME(!value || _impl_.next_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_next() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.next_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::next() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.next)
  return _internal_next();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_next(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.next_);
  }
  _impl_.next_ = reinterpret_cast<::MIDIButtonProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000040U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.next)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_next() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000040U);
  ::MIDIButtonProto* released = _impl_.next_;
  _impl_.next_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_next() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.next)

  ClearHasBit(_impl_._has_bits_[1], 0x00000040U);
  ::MIDIButtonProto* temp = _impl_.next_;
  _impl_.next_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_next() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.next_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.next_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.next_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_next()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000040U);
  ::MIDIButtonProto* _msg = _internal_mutable_next();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.next)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_next(::MIDIButtonProto* 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_.next_);
  }

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

  _impl_.next_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.next)
}

// optional int32 next_button_bank = 46;
inline bool MIDIMappingProto::has_next_button_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000800U);
  return value;
}
inline void MIDIMappingProto::clear_next_button_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.next_button_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[1], 0x00000800U);
}
inline ::int32_t MIDIMappingProto::next_button_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.next_button_bank)
  return _internal_next_button_bank();
}
inline void MIDIMappingProto::set_next_button_bank(::int32_t value) {
  _internal_set_next_button_bank(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000800U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.next_button_bank)
}
inline ::int32_t MIDIMappingProto::_internal_next_button_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.next_button_bank_;
}
inline void MIDIMappingProto::_internal_set_next_button_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.next_button_bank_ = value;
}

// optional .MIDILightProto next_ready = 47;
inline bool MIDIMappingProto::has_next_ready() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000080U);
  PROTOBUF_ASSUME(!value || _impl_.next_ready_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_next_ready() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.next_ready_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::next_ready() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.next_ready)
  return _internal_next_ready();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_next_ready(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.next_ready_);
  }
  _impl_.next_ready_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000080U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.next_ready)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_next_ready() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000080U);
  ::MIDILightProto* released = _impl_.next_ready_;
  _impl_.next_ready_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_next_ready() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.next_ready)

  ClearHasBit(_impl_._has_bits_[1], 0x00000080U);
  ::MIDILightProto* temp = _impl_.next_ready_;
  _impl_.next_ready_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_next_ready() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.next_ready_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.next_ready_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.next_ready_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_next_ready()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000080U);
  ::MIDILightProto* _msg = _internal_mutable_next_ready();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.next_ready)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_next_ready(::MIDILightProto* 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_.next_ready_);
  }

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

  _impl_.next_ready_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.next_ready)
}

// optional .MIDIButtonProto toggle_lock = 36;
inline bool MIDIMappingProto::has_toggle_lock() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.toggle_lock_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_toggle_lock() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.toggle_lock_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::toggle_lock() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.toggle_lock)
  return _internal_toggle_lock();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_toggle_lock(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.toggle_lock_);
  }
  _impl_.toggle_lock_ = reinterpret_cast<::MIDIButtonProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.toggle_lock)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_toggle_lock() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  ::MIDIButtonProto* released = _impl_.toggle_lock_;
  _impl_.toggle_lock_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_toggle_lock() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.toggle_lock)

  ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  ::MIDIButtonProto* temp = _impl_.toggle_lock_;
  _impl_.toggle_lock_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_toggle_lock() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.toggle_lock_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.toggle_lock_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.toggle_lock_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_toggle_lock()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  ::MIDIButtonProto* _msg = _internal_mutable_toggle_lock();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.toggle_lock)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_toggle_lock(::MIDIButtonProto* 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_.toggle_lock_);
  }

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

  _impl_.toggle_lock_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.toggle_lock)
}

// optional int32 toggle_lock_bank = 37;
inline bool MIDIMappingProto::has_toggle_lock_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000200U);
  return value;
}
inline void MIDIMappingProto::clear_toggle_lock_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_lock_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[1], 0x00000200U);
}
inline ::int32_t MIDIMappingProto::toggle_lock_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.toggle_lock_bank)
  return _internal_toggle_lock_bank();
}
inline void MIDIMappingProto::set_toggle_lock_bank(::int32_t value) {
  _internal_set_toggle_lock_bank(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000200U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.toggle_lock_bank)
}
inline ::int32_t MIDIMappingProto::_internal_toggle_lock_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.toggle_lock_bank_;
}
inline void MIDIMappingProto::_internal_set_toggle_lock_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_lock_bank_ = value;
}

// optional .MIDILightProto locked = 38;
inline bool MIDIMappingProto::has_locked() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.locked_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_locked() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.locked_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::locked() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.locked)
  return _internal_locked();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_locked(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.locked_);
  }
  _impl_.locked_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.locked)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_locked() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000002U);
  ::MIDILightProto* released = _impl_.locked_;
  _impl_.locked_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_locked() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.locked)

  ClearHasBit(_impl_._has_bits_[1], 0x00000002U);
  ::MIDILightProto* temp = _impl_.locked_;
  _impl_.locked_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_locked() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.locked_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.locked_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.locked_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_locked()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000002U);
  ::MIDILightProto* _msg = _internal_mutable_locked();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.locked)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_locked(::MIDILightProto* 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_.locked_);
  }

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

  _impl_.locked_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.locked)
}

// optional .MIDILightProto locked_blinking = 39;
inline bool MIDIMappingProto::has_locked_blinking() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.locked_blinking_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_locked_blinking() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.locked_blinking_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::locked_blinking() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.locked_blinking)
  return _internal_locked_blinking();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_locked_blinking(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.locked_blinking_);
  }
  _impl_.locked_blinking_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.locked_blinking)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_locked_blinking() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000004U);
  ::MIDILightProto* released = _impl_.locked_blinking_;
  _impl_.locked_blinking_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_locked_blinking() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.locked_blinking)

  ClearHasBit(_impl_._has_bits_[1], 0x00000004U);
  ::MIDILightProto* temp = _impl_.locked_blinking_;
  _impl_.locked_blinking_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_locked_blinking() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.locked_blinking_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.locked_blinking_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.locked_blinking_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_locked_blinking()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000004U);
  ::MIDILightProto* _msg = _internal_mutable_locked_blinking();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.locked_blinking)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_locked_blinking(::MIDILightProto* 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_.locked_blinking_);
  }

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

  _impl_.locked_blinking_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.locked_blinking)
}

// optional .MIDIButtonProto cue_in = 27;
inline bool MIDIMappingProto::has_cue_in() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00080000U);
  PROTOBUF_ASSUME(!value || _impl_.cue_in_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_cue_in() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.cue_in_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::cue_in() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.cue_in)
  return _internal_cue_in();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_cue_in(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cue_in_);
  }
  _impl_.cue_in_ = reinterpret_cast<::MIDIButtonProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.cue_in)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_cue_in() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
  ::MIDIButtonProto* released = _impl_.cue_in_;
  _impl_.cue_in_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_cue_in() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.cue_in)

  ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
  ::MIDIButtonProto* temp = _impl_.cue_in_;
  _impl_.cue_in_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_cue_in() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.cue_in_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.cue_in_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.cue_in_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_cue_in()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  ::MIDIButtonProto* _msg = _internal_mutable_cue_in();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.cue_in)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_cue_in(::MIDIButtonProto* 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_.cue_in_);
  }

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

  _impl_.cue_in_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.cue_in)
}

// optional int32 cue_in_bank = 28;
inline bool MIDIMappingProto::has_cue_in_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x08000000U);
  return value;
}
inline void MIDIMappingProto::clear_cue_in_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cue_in_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x08000000U);
}
inline ::int32_t MIDIMappingProto::cue_in_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.cue_in_bank)
  return _internal_cue_in_bank();
}
inline void MIDIMappingProto::set_cue_in_bank(::int32_t value) {
  _internal_set_cue_in_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x08000000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.cue_in_bank)
}
inline ::int32_t MIDIMappingProto::_internal_cue_in_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cue_in_bank_;
}
inline void MIDIMappingProto::_internal_set_cue_in_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cue_in_bank_ = value;
}

// optional .MIDILightProto cue_in_enabled = 29;
inline bool MIDIMappingProto::has_cue_in_enabled() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00100000U);
  PROTOBUF_ASSUME(!value || _impl_.cue_in_enabled_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_cue_in_enabled() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.cue_in_enabled_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::cue_in_enabled() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.cue_in_enabled)
  return _internal_cue_in_enabled();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_cue_in_enabled(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cue_in_enabled_);
  }
  _impl_.cue_in_enabled_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.cue_in_enabled)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_cue_in_enabled() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
  ::MIDILightProto* released = _impl_.cue_in_enabled_;
  _impl_.cue_in_enabled_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_cue_in_enabled() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.cue_in_enabled)

  ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
  ::MIDILightProto* temp = _impl_.cue_in_enabled_;
  _impl_.cue_in_enabled_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_cue_in_enabled() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.cue_in_enabled_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.cue_in_enabled_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.cue_in_enabled_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_cue_in_enabled()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  ::MIDILightProto* _msg = _internal_mutable_cue_in_enabled();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.cue_in_enabled)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_cue_in_enabled(::MIDILightProto* 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_.cue_in_enabled_);
  }

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

  _impl_.cue_in_enabled_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.cue_in_enabled)
}

// optional .MIDIButtonProto cue_out = 30;
inline bool MIDIMappingProto::has_cue_out() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00200000U);
  PROTOBUF_ASSUME(!value || _impl_.cue_out_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingProto::_internal_cue_out() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.cue_out_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingProto::cue_out() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.cue_out)
  return _internal_cue_out();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_cue_out(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cue_out_);
  }
  _impl_.cue_out_ = reinterpret_cast<::MIDIButtonProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.cue_out)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::release_cue_out() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
  ::MIDIButtonProto* released = _impl_.cue_out_;
  _impl_.cue_out_ = 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 ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_cue_out() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.cue_out)

  ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
  ::MIDIButtonProto* temp = _impl_.cue_out_;
  _impl_.cue_out_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_cue_out() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.cue_out_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.cue_out_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.cue_out_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_cue_out()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  ::MIDIButtonProto* _msg = _internal_mutable_cue_out();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.cue_out)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_cue_out(::MIDIButtonProto* 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_.cue_out_);
  }

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

  _impl_.cue_out_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.cue_out)
}

// optional int32 cue_out_bank = 31;
inline bool MIDIMappingProto::has_cue_out_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x10000000U);
  return value;
}
inline void MIDIMappingProto::clear_cue_out_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cue_out_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
}
inline ::int32_t MIDIMappingProto::cue_out_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.cue_out_bank)
  return _internal_cue_out_bank();
}
inline void MIDIMappingProto::set_cue_out_bank(::int32_t value) {
  _internal_set_cue_out_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x10000000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.cue_out_bank)
}
inline ::int32_t MIDIMappingProto::_internal_cue_out_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cue_out_bank_;
}
inline void MIDIMappingProto::_internal_set_cue_out_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cue_out_bank_ = value;
}

// optional .MIDILightProto cue_out_enabled = 32;
inline bool MIDIMappingProto::has_cue_out_enabled() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x40000000U);
  PROTOBUF_ASSUME(!value || _impl_.cue_out_enabled_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingProto::_internal_cue_out_enabled() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.cue_out_enabled_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingProto::cue_out_enabled() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.cue_out_enabled)
  return _internal_cue_out_enabled();
}
inline void MIDIMappingProto::unsafe_arena_set_allocated_cue_out_enabled(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cue_out_enabled_);
  }
  _impl_.cue_out_enabled_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingProto.cue_out_enabled)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::release_cue_out_enabled() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
  ::MIDILightProto* released = _impl_.cue_out_enabled_;
  _impl_.cue_out_enabled_ = 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 ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingProto::unsafe_arena_release_cue_out_enabled() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingProto.cue_out_enabled)

  ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
  ::MIDILightProto* temp = _impl_.cue_out_enabled_;
  _impl_.cue_out_enabled_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::_internal_mutable_cue_out_enabled() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.cue_out_enabled_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.cue_out_enabled_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.cue_out_enabled_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_cue_out_enabled()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  ::MIDILightProto* _msg = _internal_mutable_cue_out_enabled();
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.cue_out_enabled)
  return _msg;
}
inline void MIDIMappingProto::set_allocated_cue_out_enabled(::MIDILightProto* 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_.cue_out_enabled_);
  }

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

  _impl_.cue_out_enabled_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingProto.cue_out_enabled)
}

// repeated .CameraMIDIMappingProto camera = 33;
inline int MIDIMappingProto::_internal_camera_size() const {
  return _internal_camera().size();
}
inline int MIDIMappingProto::camera_size() const {
  return _internal_camera_size();
}
inline void MIDIMappingProto::clear_camera() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.camera_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
}
inline const ::CameraMIDIMappingProto& MIDIMappingProto::camera(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.camera)
  return _internal_camera().Get(index);
}
inline ::CameraMIDIMappingProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_camera(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.camera)
  return _internal_mutable_camera()->Mutable(index);
}
inline ::CameraMIDIMappingProto* PROTOBUF_NONNULL MIDIMappingProto::add_camera()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::CameraMIDIMappingProto* _add =
      _internal_mutable_camera()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  // @@protoc_insertion_point(field_add:MIDIMappingProto.camera)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::CameraMIDIMappingProto>& MIDIMappingProto::camera() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:MIDIMappingProto.camera)
  return _internal_camera();
}
inline ::google::protobuf::RepeatedPtrField<::CameraMIDIMappingProto>* PROTOBUF_NONNULL
MIDIMappingProto::mutable_camera() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  // @@protoc_insertion_point(field_mutable_list:MIDIMappingProto.camera)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_camera();
}
inline const ::google::protobuf::RepeatedPtrField<::CameraMIDIMappingProto>&
MIDIMappingProto::_internal_camera() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.camera_;
}
inline ::google::protobuf::RepeatedPtrField<::CameraMIDIMappingProto>* PROTOBUF_NONNULL
MIDIMappingProto::_internal_mutable_camera() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.camera_;
}

#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  // futatabi_5fmidi_5fmapping_2eproto_2epb_2eh
