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

#ifndef nageru_5fmidi_5fmapping_2eproto_2epb_2eh
#define nageru_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_nageru_5fmidi_5fmapping_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_nageru_5fmidi_5fmapping_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_nageru_5fmidi_5fmapping_2eproto;
}  // extern "C"
class MIDIMappingBusProto;
struct MIDIMappingBusProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern MIDIMappingBusProtoGlobalsTypeInternal MIDIMappingBusProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull MIDIMappingBusProto_class_data_;
#else
extern const MIDIMappingBusProtoGlobalsTypeInternal MIDIMappingBusProto_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 MIDIMappingBusProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:MIDIMappingBusProto) */ {
  using Super_ = ::google::protobuf::Message;

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

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

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

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

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

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

  explicit MIDIMappingBusProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  MIDIMappingBusProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const MIDIMappingBusProto& from);
  MIDIMappingBusProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, MIDIMappingBusProto&& from) noexcept
      : MIDIMappingBusProto(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 {
    kTrebleFieldNumber = 2,
    kMidFieldNumber = 3,
    kBassFieldNumber = 4,
    kGainFieldNumber = 5,
    kCompressorThresholdFieldNumber = 6,
    kFaderFieldNumber = 7,
    kToggleMuteFieldNumber = 8,
    kToggleLocutFieldNumber = 9,
    kToggleAutoGainStagingFieldNumber = 10,
    kToggleCompressorFieldNumber = 11,
    kClearPeakFieldNumber = 12,
    kPrevBankFieldNumber = 13,
    kNextBankFieldNumber = 14,
    kSelectBank1FieldNumber = 15,
    kSelectBank2FieldNumber = 16,
    kSelectBank3FieldNumber = 17,
    kSelectBank4FieldNumber = 18,
    kSelectBank5FieldNumber = 19,
    kToggleLimiterFieldNumber = 20,
    kToggleAutoMakeupGainFieldNumber = 21,
    kLocutFieldNumber = 22,
    kLimiterThresholdFieldNumber = 23,
    kMakeupGainFieldNumber = 24,
    kIsMutedFieldNumber = 25,
    kLocutIsOnFieldNumber = 26,
    kAutoGainStagingIsOnFieldNumber = 27,
    kCompressorIsOnFieldNumber = 28,
    kHasPeakedFieldNumber = 29,
    kBank1IsSelectedFieldNumber = 30,
    kBank2IsSelectedFieldNumber = 31,
    kBank3IsSelectedFieldNumber = 32,
    kBank4IsSelectedFieldNumber = 33,
    kBank5IsSelectedFieldNumber = 34,
    kLimiterIsOnFieldNumber = 35,
    kAutoMakeupGainIsOnFieldNumber = 36,
    kStereoWidthFieldNumber = 37,
    kSwitchVideoChannelFieldNumber = 38,
    kApplyTransitionFieldNumber = 39,
    kPrevAudioViewFieldNumber = 40,
    kNextAudioViewFieldNumber = 41,
    kBeginNewVideoSegmentFieldNumber = 42,
    kExitFieldNumber = 43,
  };
  // optional .MIDIControllerProto treble = 2;
  [[nodiscard]] bool has_treble() const;
  void clear_treble() ;
  [[nodiscard]] const ::MIDIControllerProto& treble() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_treble();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_treble();
  void set_allocated_treble(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_treble(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_treble();

  private:
  const ::MIDIControllerProto& _internal_treble() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_treble();

  public:
  // optional .MIDIControllerProto mid = 3;
  [[nodiscard]] bool has_mid() const;
  void clear_mid() ;
  [[nodiscard]] const ::MIDIControllerProto& mid() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_mid();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_mid();
  void set_allocated_mid(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_mid(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_mid();

  private:
  const ::MIDIControllerProto& _internal_mid() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_mid();

  public:
  // optional .MIDIControllerProto bass = 4;
  [[nodiscard]] bool has_bass() const;
  void clear_bass() ;
  [[nodiscard]] const ::MIDIControllerProto& bass() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_bass();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_bass();
  void set_allocated_bass(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_bass(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_bass();

  private:
  const ::MIDIControllerProto& _internal_bass() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_bass();

  public:
  // optional .MIDIControllerProto gain = 5;
  [[nodiscard]] bool has_gain() const;
  void clear_gain() ;
  [[nodiscard]] const ::MIDIControllerProto& gain() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_gain();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_gain();
  void set_allocated_gain(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_gain(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_gain();

  private:
  const ::MIDIControllerProto& _internal_gain() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_gain();

  public:
  // optional .MIDIControllerProto compressor_threshold = 6;
  [[nodiscard]] bool has_compressor_threshold() const;
  void clear_compressor_threshold() ;
  [[nodiscard]] const ::MIDIControllerProto& compressor_threshold() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_compressor_threshold();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_compressor_threshold();
  void set_allocated_compressor_threshold(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_compressor_threshold(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_compressor_threshold();

  private:
  const ::MIDIControllerProto& _internal_compressor_threshold() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_compressor_threshold();

  public:
  // optional .MIDIControllerProto fader = 7;
  [[nodiscard]] bool has_fader() const;
  void clear_fader() ;
  [[nodiscard]] const ::MIDIControllerProto& fader() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_fader();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_fader();
  void set_allocated_fader(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_fader(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_fader();

  private:
  const ::MIDIControllerProto& _internal_fader() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_fader();

  public:
  // optional .MIDIButtonProto toggle_mute = 8;
  [[nodiscard]] bool has_toggle_mute() const;
  void clear_toggle_mute() ;
  [[nodiscard]] const ::MIDIButtonProto& toggle_mute() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_toggle_mute();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_toggle_mute();
  void set_allocated_toggle_mute(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_toggle_mute(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_toggle_mute();

  private:
  const ::MIDIButtonProto& _internal_toggle_mute() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_toggle_mute();

  public:
  // optional .MIDIButtonProto toggle_locut = 9;
  [[nodiscard]] bool has_toggle_locut() const;
  void clear_toggle_locut() ;
  [[nodiscard]] const ::MIDIButtonProto& toggle_locut() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_toggle_locut();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_toggle_locut();
  void set_allocated_toggle_locut(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_toggle_locut(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_toggle_locut();

  private:
  const ::MIDIButtonProto& _internal_toggle_locut() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_toggle_locut();

  public:
  // optional .MIDIButtonProto toggle_auto_gain_staging = 10;
  [[nodiscard]] bool has_toggle_auto_gain_staging() const;
  void clear_toggle_auto_gain_staging() ;
  [[nodiscard]] const ::MIDIButtonProto& toggle_auto_gain_staging() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_toggle_auto_gain_staging();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_toggle_auto_gain_staging();
  void set_allocated_toggle_auto_gain_staging(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_toggle_auto_gain_staging(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_toggle_auto_gain_staging();

  private:
  const ::MIDIButtonProto& _internal_toggle_auto_gain_staging() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_toggle_auto_gain_staging();

  public:
  // optional .MIDIButtonProto toggle_compressor = 11;
  [[nodiscard]] bool has_toggle_compressor() const;
  void clear_toggle_compressor() ;
  [[nodiscard]] const ::MIDIButtonProto& toggle_compressor() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_toggle_compressor();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_toggle_compressor();
  void set_allocated_toggle_compressor(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_toggle_compressor(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_toggle_compressor();

  private:
  const ::MIDIButtonProto& _internal_toggle_compressor() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_toggle_compressor();

  public:
  // optional .MIDIButtonProto clear_peak = 12;
  [[nodiscard]] bool has_clear_peak() const;
  void clear_clear_peak() ;
  [[nodiscard]] const ::MIDIButtonProto& clear_peak() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_clear_peak();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_clear_peak();
  void set_allocated_clear_peak(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_clear_peak(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_clear_peak();

  private:
  const ::MIDIButtonProto& _internal_clear_peak() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_clear_peak();

  public:
  // optional .MIDIButtonProto prev_bank = 13;
  [[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 = 14;
  [[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 = 15;
  [[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 = 16;
  [[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 = 17;
  [[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 = 18;
  [[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 = 19;
  [[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 .MIDIButtonProto toggle_limiter = 20;
  [[nodiscard]] bool has_toggle_limiter() const;
  void clear_toggle_limiter() ;
  [[nodiscard]] const ::MIDIButtonProto& toggle_limiter() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_toggle_limiter();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_toggle_limiter();
  void set_allocated_toggle_limiter(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_toggle_limiter(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_toggle_limiter();

  private:
  const ::MIDIButtonProto& _internal_toggle_limiter() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_toggle_limiter();

  public:
  // optional .MIDIButtonProto toggle_auto_makeup_gain = 21;
  [[nodiscard]] bool has_toggle_auto_makeup_gain() const;
  void clear_toggle_auto_makeup_gain() ;
  [[nodiscard]] const ::MIDIButtonProto& toggle_auto_makeup_gain() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_toggle_auto_makeup_gain();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_toggle_auto_makeup_gain();
  void set_allocated_toggle_auto_makeup_gain(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_toggle_auto_makeup_gain(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_toggle_auto_makeup_gain();

  private:
  const ::MIDIButtonProto& _internal_toggle_auto_makeup_gain() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_toggle_auto_makeup_gain();

  public:
  // optional .MIDIControllerProto locut = 22;
  [[nodiscard]] bool has_locut() const;
  void clear_locut() ;
  [[nodiscard]] const ::MIDIControllerProto& locut() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_locut();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_locut();
  void set_allocated_locut(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_locut(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_locut();

  private:
  const ::MIDIControllerProto& _internal_locut() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_locut();

  public:
  // optional .MIDIControllerProto limiter_threshold = 23;
  [[nodiscard]] bool has_limiter_threshold() const;
  void clear_limiter_threshold() ;
  [[nodiscard]] const ::MIDIControllerProto& limiter_threshold() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_limiter_threshold();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_limiter_threshold();
  void set_allocated_limiter_threshold(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_limiter_threshold(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_limiter_threshold();

  private:
  const ::MIDIControllerProto& _internal_limiter_threshold() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_limiter_threshold();

  public:
  // optional .MIDIControllerProto makeup_gain = 24;
  [[nodiscard]] bool has_makeup_gain() const;
  void clear_makeup_gain() ;
  [[nodiscard]] const ::MIDIControllerProto& makeup_gain() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_makeup_gain();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_makeup_gain();
  void set_allocated_makeup_gain(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_makeup_gain(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_makeup_gain();

  private:
  const ::MIDIControllerProto& _internal_makeup_gain() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_makeup_gain();

  public:
  // optional .MIDILightProto is_muted = 25;
  [[nodiscard]] bool has_is_muted() const;
  void clear_is_muted() ;
  [[nodiscard]] const ::MIDILightProto& is_muted() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_is_muted();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_is_muted();
  void set_allocated_is_muted(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_is_muted(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_is_muted();

  private:
  const ::MIDILightProto& _internal_is_muted() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_is_muted();

  public:
  // optional .MIDILightProto locut_is_on = 26;
  [[nodiscard]] bool has_locut_is_on() const;
  void clear_locut_is_on() ;
  [[nodiscard]] const ::MIDILightProto& locut_is_on() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_locut_is_on();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_locut_is_on();
  void set_allocated_locut_is_on(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_locut_is_on(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_locut_is_on();

  private:
  const ::MIDILightProto& _internal_locut_is_on() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_locut_is_on();

  public:
  // optional .MIDILightProto auto_gain_staging_is_on = 27;
  [[nodiscard]] bool has_auto_gain_staging_is_on() const;
  void clear_auto_gain_staging_is_on() ;
  [[nodiscard]] const ::MIDILightProto& auto_gain_staging_is_on() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_auto_gain_staging_is_on();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_auto_gain_staging_is_on();
  void set_allocated_auto_gain_staging_is_on(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_auto_gain_staging_is_on(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_auto_gain_staging_is_on();

  private:
  const ::MIDILightProto& _internal_auto_gain_staging_is_on() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_auto_gain_staging_is_on();

  public:
  // optional .MIDILightProto compressor_is_on = 28;
  [[nodiscard]] bool has_compressor_is_on() const;
  void clear_compressor_is_on() ;
  [[nodiscard]] const ::MIDILightProto& compressor_is_on() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_compressor_is_on();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_compressor_is_on();
  void set_allocated_compressor_is_on(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_compressor_is_on(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_compressor_is_on();

  private:
  const ::MIDILightProto& _internal_compressor_is_on() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_compressor_is_on();

  public:
  // optional .MIDILightProto has_peaked = 29;
  [[nodiscard]] bool has_has_peaked() const;
  void clear_has_peaked() ;
  [[nodiscard]] const ::MIDILightProto& has_peaked() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_has_peaked();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_has_peaked();
  void set_allocated_has_peaked(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_has_peaked(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_has_peaked();

  private:
  const ::MIDILightProto& _internal_has_peaked() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_has_peaked();

  public:
  // optional .MIDILightProto bank_1_is_selected = 30;
  [[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 = 31;
  [[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 = 32;
  [[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 = 33;
  [[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 = 34;
  [[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 .MIDILightProto limiter_is_on = 35;
  [[nodiscard]] bool has_limiter_is_on() const;
  void clear_limiter_is_on() ;
  [[nodiscard]] const ::MIDILightProto& limiter_is_on() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_limiter_is_on();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_limiter_is_on();
  void set_allocated_limiter_is_on(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_limiter_is_on(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_limiter_is_on();

  private:
  const ::MIDILightProto& _internal_limiter_is_on() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_limiter_is_on();

  public:
  // optional .MIDILightProto auto_makeup_gain_is_on = 36;
  [[nodiscard]] bool has_auto_makeup_gain_is_on() const;
  void clear_auto_makeup_gain_is_on() ;
  [[nodiscard]] const ::MIDILightProto& auto_makeup_gain_is_on() const;
  [[nodiscard]] ::MIDILightProto* PROTOBUF_NULLABLE release_auto_makeup_gain_is_on();
  ::MIDILightProto* PROTOBUF_NONNULL mutable_auto_makeup_gain_is_on();
  void set_allocated_auto_makeup_gain_is_on(::MIDILightProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_auto_makeup_gain_is_on(::MIDILightProto* PROTOBUF_NULLABLE value);
  ::MIDILightProto* PROTOBUF_NULLABLE unsafe_arena_release_auto_makeup_gain_is_on();

  private:
  const ::MIDILightProto& _internal_auto_makeup_gain_is_on() const;
  ::MIDILightProto* PROTOBUF_NONNULL _internal_mutable_auto_makeup_gain_is_on();

  public:
  // optional .MIDIControllerProto stereo_width = 37;
  [[nodiscard]] bool has_stereo_width() const;
  void clear_stereo_width() ;
  [[nodiscard]] const ::MIDIControllerProto& stereo_width() const;
  [[nodiscard]] ::MIDIControllerProto* PROTOBUF_NULLABLE release_stereo_width();
  ::MIDIControllerProto* PROTOBUF_NONNULL mutable_stereo_width();
  void set_allocated_stereo_width(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_stereo_width(::MIDIControllerProto* PROTOBUF_NULLABLE value);
  ::MIDIControllerProto* PROTOBUF_NULLABLE unsafe_arena_release_stereo_width();

  private:
  const ::MIDIControllerProto& _internal_stereo_width() const;
  ::MIDIControllerProto* PROTOBUF_NONNULL _internal_mutable_stereo_width();

  public:
  // optional .MIDIButtonProto switch_video_channel = 38;
  [[nodiscard]] bool has_switch_video_channel() const;
  void clear_switch_video_channel() ;
  [[nodiscard]] const ::MIDIButtonProto& switch_video_channel() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_switch_video_channel();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_switch_video_channel();
  void set_allocated_switch_video_channel(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_switch_video_channel(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_switch_video_channel();

  private:
  const ::MIDIButtonProto& _internal_switch_video_channel() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_switch_video_channel();

  public:
  // optional .MIDIButtonProto apply_transition = 39;
  [[nodiscard]] bool has_apply_transition() const;
  void clear_apply_transition() ;
  [[nodiscard]] const ::MIDIButtonProto& apply_transition() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_apply_transition();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_apply_transition();
  void set_allocated_apply_transition(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_apply_transition(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_apply_transition();

  private:
  const ::MIDIButtonProto& _internal_apply_transition() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_apply_transition();

  public:
  // optional .MIDIButtonProto prev_audio_view = 40;
  [[nodiscard]] bool has_prev_audio_view() const;
  void clear_prev_audio_view() ;
  [[nodiscard]] const ::MIDIButtonProto& prev_audio_view() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_prev_audio_view();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_prev_audio_view();
  void set_allocated_prev_audio_view(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_prev_audio_view(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_prev_audio_view();

  private:
  const ::MIDIButtonProto& _internal_prev_audio_view() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_prev_audio_view();

  public:
  // optional .MIDIButtonProto next_audio_view = 41;
  [[nodiscard]] bool has_next_audio_view() const;
  void clear_next_audio_view() ;
  [[nodiscard]] const ::MIDIButtonProto& next_audio_view() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_next_audio_view();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_next_audio_view();
  void set_allocated_next_audio_view(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_next_audio_view(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_next_audio_view();

  private:
  const ::MIDIButtonProto& _internal_next_audio_view() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_next_audio_view();

  public:
  // optional .MIDIButtonProto begin_new_video_segment = 42;
  [[nodiscard]] bool has_begin_new_video_segment() const;
  void clear_begin_new_video_segment() ;
  [[nodiscard]] const ::MIDIButtonProto& begin_new_video_segment() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_begin_new_video_segment();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_begin_new_video_segment();
  void set_allocated_begin_new_video_segment(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_begin_new_video_segment(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_begin_new_video_segment();

  private:
  const ::MIDIButtonProto& _internal_begin_new_video_segment() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_begin_new_video_segment();

  public:
  // optional .MIDIButtonProto exit = 43;
  [[nodiscard]] bool has_exit() const;
  void clear_exit() ;
  [[nodiscard]] const ::MIDIButtonProto& exit() const;
  [[nodiscard]] ::MIDIButtonProto* PROTOBUF_NULLABLE release_exit();
  ::MIDIButtonProto* PROTOBUF_NONNULL mutable_exit();
  void set_allocated_exit(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_exit(::MIDIButtonProto* PROTOBUF_NULLABLE value);
  ::MIDIButtonProto* PROTOBUF_NULLABLE unsafe_arena_release_exit();

  private:
  const ::MIDIButtonProto& _internal_exit() const;
  ::MIDIButtonProto* PROTOBUF_NONNULL _internal_mutable_exit();

  public:
  // @@protoc_insertion_point(class_scope:MIDIMappingBusProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<5, 42,
                          42, 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 MIDIMappingBusProto& from_msg);
    ::google::protobuf::internal::HasBits<2> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE treble_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE mid_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE bass_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE gain_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE compressor_threshold_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE fader_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE toggle_mute_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE toggle_locut_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE toggle_auto_gain_staging_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE toggle_compressor_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE clear_peak_;
    ::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_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE toggle_limiter_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE toggle_auto_makeup_gain_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE locut_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE limiter_threshold_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE makeup_gain_;
    ::MIDILightProto* PROTOBUF_NULLABLE is_muted_;
    ::MIDILightProto* PROTOBUF_NULLABLE locut_is_on_;
    ::MIDILightProto* PROTOBUF_NULLABLE auto_gain_staging_is_on_;
    ::MIDILightProto* PROTOBUF_NULLABLE compressor_is_on_;
    ::MIDILightProto* PROTOBUF_NULLABLE has_peaked_;
    ::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_;
    ::MIDILightProto* PROTOBUF_NULLABLE limiter_is_on_;
    ::MIDILightProto* PROTOBUF_NULLABLE auto_makeup_gain_is_on_;
    ::MIDIControllerProto* PROTOBUF_NULLABLE stereo_width_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE switch_video_channel_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE apply_transition_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE prev_audio_view_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE next_audio_view_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE begin_new_video_segment_;
    ::MIDIButtonProto* PROTOBUF_NULLABLE exit_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_nageru_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 {
    kBusMappingFieldNumber = 18,
    kNumControllerBanksFieldNumber = 1,
    kTrebleBankFieldNumber = 2,
    kMidBankFieldNumber = 3,
    kBassBankFieldNumber = 4,
    kGainBankFieldNumber = 5,
    kCompressorThresholdBankFieldNumber = 6,
    kFaderBankFieldNumber = 7,
    kToggleMuteBankFieldNumber = 8,
    kToggleLocutBankFieldNumber = 9,
    kToggleAutoGainStagingBankFieldNumber = 10,
    kToggleCompressorBankFieldNumber = 11,
    kClearPeakBankFieldNumber = 12,
    kLocutBankFieldNumber = 13,
    kLimiterThresholdBankFieldNumber = 14,
    kMakeupGainBankFieldNumber = 15,
    kToggleLimiterBankFieldNumber = 16,
    kToggleAutoMakeupGainBankFieldNumber = 17,
    kStereoWidthBankFieldNumber = 19,
    kPrevAudioViewBankFieldNumber = 20,
    kNextAudioViewBankFieldNumber = 21,
    kBeginNewVideoSegmentBankFieldNumber = 22,
    kExitBankFieldNumber = 23,
    kSwitchVideoChannelBankFieldNumber = 24,
    kApplyTransitionBankFieldNumber = 25,
  };
  // repeated .MIDIMappingBusProto bus_mapping = 18;
  [[nodiscard]] int bus_mapping_size() const;
  private:
  int _internal_bus_mapping_size() const;

  public:
  void clear_bus_mapping() ;
  [[nodiscard]] const ::MIDIMappingBusProto& bus_mapping(int index) const;
  [[nodiscard]] ::MIDIMappingBusProto* PROTOBUF_NONNULL mutable_bus_mapping(int index);
  ::MIDIMappingBusProto* PROTOBUF_NONNULL add_bus_mapping();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::MIDIMappingBusProto>&
  bus_mapping() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::MIDIMappingBusProto>* PROTOBUF_NONNULL
  mutable_bus_mapping();

  private:
  const ::google::protobuf::RepeatedPtrField<::MIDIMappingBusProto>& _internal_bus_mapping() const;
  ::google::protobuf::RepeatedPtrField<::MIDIMappingBusProto>* PROTOBUF_NONNULL _internal_mutable_bus_mapping();

  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 treble_bank = 2;
  [[nodiscard]] bool has_treble_bank() const;
  void clear_treble_bank() ;
  [[nodiscard]] ::int32_t treble_bank() const;
  void set_treble_bank(::int32_t value);

  private:
  ::int32_t _internal_treble_bank() const;
  void _internal_set_treble_bank(::int32_t value);

  public:
  // optional int32 mid_bank = 3;
  [[nodiscard]] bool has_mid_bank() const;
  void clear_mid_bank() ;
  [[nodiscard]] ::int32_t mid_bank() const;
  void set_mid_bank(::int32_t value);

  private:
  ::int32_t _internal_mid_bank() const;
  void _internal_set_mid_bank(::int32_t value);

  public:
  // optional int32 bass_bank = 4;
  [[nodiscard]] bool has_bass_bank() const;
  void clear_bass_bank() ;
  [[nodiscard]] ::int32_t bass_bank() const;
  void set_bass_bank(::int32_t value);

  private:
  ::int32_t _internal_bass_bank() const;
  void _internal_set_bass_bank(::int32_t value);

  public:
  // optional int32 gain_bank = 5;
  [[nodiscard]] bool has_gain_bank() const;
  void clear_gain_bank() ;
  [[nodiscard]] ::int32_t gain_bank() const;
  void set_gain_bank(::int32_t value);

  private:
  ::int32_t _internal_gain_bank() const;
  void _internal_set_gain_bank(::int32_t value);

  public:
  // optional int32 compressor_threshold_bank = 6;
  [[nodiscard]] bool has_compressor_threshold_bank() const;
  void clear_compressor_threshold_bank() ;
  [[nodiscard]] ::int32_t compressor_threshold_bank() const;
  void set_compressor_threshold_bank(::int32_t value);

  private:
  ::int32_t _internal_compressor_threshold_bank() const;
  void _internal_set_compressor_threshold_bank(::int32_t value);

  public:
  // optional int32 fader_bank = 7;
  [[nodiscard]] bool has_fader_bank() const;
  void clear_fader_bank() ;
  [[nodiscard]] ::int32_t fader_bank() const;
  void set_fader_bank(::int32_t value);

  private:
  ::int32_t _internal_fader_bank() const;
  void _internal_set_fader_bank(::int32_t value);

  public:
  // optional int32 toggle_mute_bank = 8;
  [[nodiscard]] bool has_toggle_mute_bank() const;
  void clear_toggle_mute_bank() ;
  [[nodiscard]] ::int32_t toggle_mute_bank() const;
  void set_toggle_mute_bank(::int32_t value);

  private:
  ::int32_t _internal_toggle_mute_bank() const;
  void _internal_set_toggle_mute_bank(::int32_t value);

  public:
  // optional int32 toggle_locut_bank = 9;
  [[nodiscard]] bool has_toggle_locut_bank() const;
  void clear_toggle_locut_bank() ;
  [[nodiscard]] ::int32_t toggle_locut_bank() const;
  void set_toggle_locut_bank(::int32_t value);

  private:
  ::int32_t _internal_toggle_locut_bank() const;
  void _internal_set_toggle_locut_bank(::int32_t value);

  public:
  // optional int32 toggle_auto_gain_staging_bank = 10;
  [[nodiscard]] bool has_toggle_auto_gain_staging_bank() const;
  void clear_toggle_auto_gain_staging_bank() ;
  [[nodiscard]] ::int32_t toggle_auto_gain_staging_bank() const;
  void set_toggle_auto_gain_staging_bank(::int32_t value);

  private:
  ::int32_t _internal_toggle_auto_gain_staging_bank() const;
  void _internal_set_toggle_auto_gain_staging_bank(::int32_t value);

  public:
  // optional int32 toggle_compressor_bank = 11;
  [[nodiscard]] bool has_toggle_compressor_bank() const;
  void clear_toggle_compressor_bank() ;
  [[nodiscard]] ::int32_t toggle_compressor_bank() const;
  void set_toggle_compressor_bank(::int32_t value);

  private:
  ::int32_t _internal_toggle_compressor_bank() const;
  void _internal_set_toggle_compressor_bank(::int32_t value);

  public:
  // optional int32 clear_peak_bank = 12;
  [[nodiscard]] bool has_clear_peak_bank() const;
  void clear_clear_peak_bank() ;
  [[nodiscard]] ::int32_t clear_peak_bank() const;
  void set_clear_peak_bank(::int32_t value);

  private:
  ::int32_t _internal_clear_peak_bank() const;
  void _internal_set_clear_peak_bank(::int32_t value);

  public:
  // optional int32 locut_bank = 13;
  [[nodiscard]] bool has_locut_bank() const;
  void clear_locut_bank() ;
  [[nodiscard]] ::int32_t locut_bank() const;
  void set_locut_bank(::int32_t value);

  private:
  ::int32_t _internal_locut_bank() const;
  void _internal_set_locut_bank(::int32_t value);

  public:
  // optional int32 limiter_threshold_bank = 14;
  [[nodiscard]] bool has_limiter_threshold_bank() const;
  void clear_limiter_threshold_bank() ;
  [[nodiscard]] ::int32_t limiter_threshold_bank() const;
  void set_limiter_threshold_bank(::int32_t value);

  private:
  ::int32_t _internal_limiter_threshold_bank() const;
  void _internal_set_limiter_threshold_bank(::int32_t value);

  public:
  // optional int32 makeup_gain_bank = 15;
  [[nodiscard]] bool has_makeup_gain_bank() const;
  void clear_makeup_gain_bank() ;
  [[nodiscard]] ::int32_t makeup_gain_bank() const;
  void set_makeup_gain_bank(::int32_t value);

  private:
  ::int32_t _internal_makeup_gain_bank() const;
  void _internal_set_makeup_gain_bank(::int32_t value);

  public:
  // optional int32 toggle_limiter_bank = 16;
  [[nodiscard]] bool has_toggle_limiter_bank() const;
  void clear_toggle_limiter_bank() ;
  [[nodiscard]] ::int32_t toggle_limiter_bank() const;
  void set_toggle_limiter_bank(::int32_t value);

  private:
  ::int32_t _internal_toggle_limiter_bank() const;
  void _internal_set_toggle_limiter_bank(::int32_t value);

  public:
  // optional int32 toggle_auto_makeup_gain_bank = 17;
  [[nodiscard]] bool has_toggle_auto_makeup_gain_bank() const;
  void clear_toggle_auto_makeup_gain_bank() ;
  [[nodiscard]] ::int32_t toggle_auto_makeup_gain_bank() const;
  void set_toggle_auto_makeup_gain_bank(::int32_t value);

  private:
  ::int32_t _internal_toggle_auto_makeup_gain_bank() const;
  void _internal_set_toggle_auto_makeup_gain_bank(::int32_t value);

  public:
  // optional int32 stereo_width_bank = 19;
  [[nodiscard]] bool has_stereo_width_bank() const;
  void clear_stereo_width_bank() ;
  [[nodiscard]] ::int32_t stereo_width_bank() const;
  void set_stereo_width_bank(::int32_t value);

  private:
  ::int32_t _internal_stereo_width_bank() const;
  void _internal_set_stereo_width_bank(::int32_t value);

  public:
  // optional int32 prev_audio_view_bank = 20;
  [[nodiscard]] bool has_prev_audio_view_bank() const;
  void clear_prev_audio_view_bank() ;
  [[nodiscard]] ::int32_t prev_audio_view_bank() const;
  void set_prev_audio_view_bank(::int32_t value);

  private:
  ::int32_t _internal_prev_audio_view_bank() const;
  void _internal_set_prev_audio_view_bank(::int32_t value);

  public:
  // optional int32 next_audio_view_bank = 21;
  [[nodiscard]] bool has_next_audio_view_bank() const;
  void clear_next_audio_view_bank() ;
  [[nodiscard]] ::int32_t next_audio_view_bank() const;
  void set_next_audio_view_bank(::int32_t value);

  private:
  ::int32_t _internal_next_audio_view_bank() const;
  void _internal_set_next_audio_view_bank(::int32_t value);

  public:
  // optional int32 begin_new_video_segment_bank = 22;
  [[nodiscard]] bool has_begin_new_video_segment_bank() const;
  void clear_begin_new_video_segment_bank() ;
  [[nodiscard]] ::int32_t begin_new_video_segment_bank() const;
  void set_begin_new_video_segment_bank(::int32_t value);

  private:
  ::int32_t _internal_begin_new_video_segment_bank() const;
  void _internal_set_begin_new_video_segment_bank(::int32_t value);

  public:
  // optional int32 exit_bank = 23;
  [[nodiscard]] bool has_exit_bank() const;
  void clear_exit_bank() ;
  [[nodiscard]] ::int32_t exit_bank() const;
  void set_exit_bank(::int32_t value);

  private:
  ::int32_t _internal_exit_bank() const;
  void _internal_set_exit_bank(::int32_t value);

  public:
  // optional int32 switch_video_channel_bank = 24;
  [[nodiscard]] bool has_switch_video_channel_bank() const;
  void clear_switch_video_channel_bank() ;
  [[nodiscard]] ::int32_t switch_video_channel_bank() const;
  void set_switch_video_channel_bank(::int32_t value);

  private:
  ::int32_t _internal_switch_video_channel_bank() const;
  void _internal_set_switch_video_channel_bank(::int32_t value);

  public:
  // optional int32 apply_transition_bank = 25;
  [[nodiscard]] bool has_apply_transition_bank() const;
  void clear_apply_transition_bank() ;
  [[nodiscard]] ::int32_t apply_transition_bank() const;
  void set_apply_transition_bank(::int32_t value);

  private:
  ::int32_t _internal_apply_transition_bank() const;
  void _internal_set_apply_transition_bank(::int32_t value);

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

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const MIDIMappingProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::MIDIMappingBusProto > bus_mapping_;
    ::int32_t num_controller_banks_;
    ::int32_t treble_bank_;
    ::int32_t mid_bank_;
    ::int32_t bass_bank_;
    ::int32_t gain_bank_;
    ::int32_t compressor_threshold_bank_;
    ::int32_t fader_bank_;
    ::int32_t toggle_mute_bank_;
    ::int32_t toggle_locut_bank_;
    ::int32_t toggle_auto_gain_staging_bank_;
    ::int32_t toggle_compressor_bank_;
    ::int32_t clear_peak_bank_;
    ::int32_t locut_bank_;
    ::int32_t limiter_threshold_bank_;
    ::int32_t makeup_gain_bank_;
    ::int32_t toggle_limiter_bank_;
    ::int32_t toggle_auto_makeup_gain_bank_;
    ::int32_t stereo_width_bank_;
    ::int32_t prev_audio_view_bank_;
    ::int32_t next_audio_view_bank_;
    ::int32_t begin_new_video_segment_bank_;
    ::int32_t exit_bank_;
    ::int32_t switch_video_channel_bank_;
    ::int32_t apply_transition_bank_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_nageru_5fmidi_5fmapping_2eproto;
};

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




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


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

// MIDIMappingBusProto

// optional .MIDIControllerProto stereo_width = 37;
inline bool MIDIMappingBusProto::has_stereo_width() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.stereo_width_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::_internal_stereo_width() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.stereo_width_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::stereo_width() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.stereo_width)
  return _internal_stereo_width();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_stereo_width(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.stereo_width_);
  }
  _impl_.stereo_width_ = reinterpret_cast<::MIDIControllerProto*>(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:MIDIMappingBusProto.stereo_width)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_stereo_width() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000008U);
  ::MIDIControllerProto* released = _impl_.stereo_width_;
  _impl_.stereo_width_ = 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 MIDIMappingBusProto::unsafe_arena_release_stereo_width() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.stereo_width)

  ClearHasBit(_impl_._has_bits_[1], 0x00000008U);
  ::MIDIControllerProto* temp = _impl_.stereo_width_;
  _impl_.stereo_width_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_stereo_width() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.stereo_width_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.stereo_width_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.stereo_width_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_stereo_width()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000008U);
  ::MIDIControllerProto* _msg = _internal_mutable_stereo_width();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.stereo_width)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_stereo_width(::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_.stereo_width_);
  }

  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_.stereo_width_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.stereo_width)
}

// optional .MIDIControllerProto treble = 2;
inline bool MIDIMappingBusProto::has_treble() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.treble_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::_internal_treble() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.treble_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::treble() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.treble)
  return _internal_treble();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_treble(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.treble_);
  }
  _impl_.treble_ = reinterpret_cast<::MIDIControllerProto*>(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:MIDIMappingBusProto.treble)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_treble() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::MIDIControllerProto* released = _impl_.treble_;
  _impl_.treble_ = 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 MIDIMappingBusProto::unsafe_arena_release_treble() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.treble)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::MIDIControllerProto* temp = _impl_.treble_;
  _impl_.treble_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_treble() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.treble_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.treble_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.treble_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_treble()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::MIDIControllerProto* _msg = _internal_mutable_treble();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.treble)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_treble(::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_.treble_);
  }

  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_.treble_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.treble)
}

// optional .MIDIControllerProto mid = 3;
inline bool MIDIMappingBusProto::has_mid() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.mid_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::_internal_mid() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.mid_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::mid() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.mid)
  return _internal_mid();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_mid(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.mid_);
  }
  _impl_.mid_ = reinterpret_cast<::MIDIControllerProto*>(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:MIDIMappingBusProto.mid)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_mid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::MIDIControllerProto* released = _impl_.mid_;
  _impl_.mid_ = 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 MIDIMappingBusProto::unsafe_arena_release_mid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.mid)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::MIDIControllerProto* temp = _impl_.mid_;
  _impl_.mid_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_mid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.mid_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.mid_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.mid_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_mid()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::MIDIControllerProto* _msg = _internal_mutable_mid();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.mid)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_mid(::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_.mid_);
  }

  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_.mid_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.mid)
}

// optional .MIDIControllerProto bass = 4;
inline bool MIDIMappingBusProto::has_bass() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.bass_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::_internal_bass() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.bass_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::bass() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.bass)
  return _internal_bass();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_bass(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.bass_);
  }
  _impl_.bass_ = reinterpret_cast<::MIDIControllerProto*>(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:MIDIMappingBusProto.bass)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_bass() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::MIDIControllerProto* released = _impl_.bass_;
  _impl_.bass_ = 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 MIDIMappingBusProto::unsafe_arena_release_bass() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.bass)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::MIDIControllerProto* temp = _impl_.bass_;
  _impl_.bass_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_bass() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.bass_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.bass_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.bass_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_bass()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::MIDIControllerProto* _msg = _internal_mutable_bass();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.bass)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_bass(::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_.bass_);
  }

  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_.bass_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.bass)
}

// optional .MIDIControllerProto gain = 5;
inline bool MIDIMappingBusProto::has_gain() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.gain_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::_internal_gain() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.gain_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::gain() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.gain)
  return _internal_gain();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_gain(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.gain_);
  }
  _impl_.gain_ = reinterpret_cast<::MIDIControllerProto*>(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:MIDIMappingBusProto.gain)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_gain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::MIDIControllerProto* released = _impl_.gain_;
  _impl_.gain_ = 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 MIDIMappingBusProto::unsafe_arena_release_gain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.gain)

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::MIDIControllerProto* temp = _impl_.gain_;
  _impl_.gain_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_gain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.gain_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.gain_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.gain_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_gain()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::MIDIControllerProto* _msg = _internal_mutable_gain();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.gain)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_gain(::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_.gain_);
  }

  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_.gain_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.gain)
}

// optional .MIDIControllerProto compressor_threshold = 6;
inline bool MIDIMappingBusProto::has_compressor_threshold() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.compressor_threshold_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::_internal_compressor_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.compressor_threshold_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::compressor_threshold() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.compressor_threshold)
  return _internal_compressor_threshold();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_compressor_threshold(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.compressor_threshold_);
  }
  _impl_.compressor_threshold_ = reinterpret_cast<::MIDIControllerProto*>(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:MIDIMappingBusProto.compressor_threshold)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_compressor_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::MIDIControllerProto* released = _impl_.compressor_threshold_;
  _impl_.compressor_threshold_ = 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 MIDIMappingBusProto::unsafe_arena_release_compressor_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.compressor_threshold)

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::MIDIControllerProto* temp = _impl_.compressor_threshold_;
  _impl_.compressor_threshold_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_compressor_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.compressor_threshold_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.compressor_threshold_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.compressor_threshold_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_compressor_threshold()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::MIDIControllerProto* _msg = _internal_mutable_compressor_threshold();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.compressor_threshold)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_compressor_threshold(::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_.compressor_threshold_);
  }

  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_.compressor_threshold_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.compressor_threshold)
}

// optional .MIDIControllerProto fader = 7;
inline bool MIDIMappingBusProto::has_fader() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  PROTOBUF_ASSUME(!value || _impl_.fader_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::_internal_fader() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.fader_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::fader() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.fader)
  return _internal_fader();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_fader(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.fader_);
  }
  _impl_.fader_ = reinterpret_cast<::MIDIControllerProto*>(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:MIDIMappingBusProto.fader)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_fader() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::MIDIControllerProto* released = _impl_.fader_;
  _impl_.fader_ = 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 MIDIMappingBusProto::unsafe_arena_release_fader() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.fader)

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

  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_.fader_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.fader)
}

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

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::MIDIButtonProto* released = _impl_.toggle_mute_;
  _impl_.toggle_mute_ = 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 MIDIMappingBusProto::unsafe_arena_release_toggle_mute() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.toggle_mute)

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::MIDIButtonProto* temp = _impl_.toggle_mute_;
  _impl_.toggle_mute_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_toggle_mute() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.toggle_mute_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.toggle_mute_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.toggle_mute_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_toggle_mute()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::MIDIButtonProto* _msg = _internal_mutable_toggle_mute();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.toggle_mute)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_toggle_mute(::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_mute_);
  }

  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_.toggle_mute_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.toggle_mute)
}

// optional .MIDIButtonProto toggle_locut = 9;
inline bool MIDIMappingBusProto::has_toggle_locut() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  PROTOBUF_ASSUME(!value || _impl_.toggle_locut_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_toggle_locut() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.toggle_locut_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::toggle_locut() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.toggle_locut)
  return _internal_toggle_locut();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_toggle_locut(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.toggle_locut_);
  }
  _impl_.toggle_locut_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingBusProto.toggle_locut)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_toggle_locut() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::MIDIButtonProto* released = _impl_.toggle_locut_;
  _impl_.toggle_locut_ = 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 MIDIMappingBusProto::unsafe_arena_release_toggle_locut() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.toggle_locut)

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::MIDIButtonProto* temp = _impl_.toggle_locut_;
  _impl_.toggle_locut_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_toggle_locut() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.toggle_locut_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.toggle_locut_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.toggle_locut_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_toggle_locut()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::MIDIButtonProto* _msg = _internal_mutable_toggle_locut();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.toggle_locut)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_toggle_locut(::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_locut_);
  }

  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_.toggle_locut_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.toggle_locut)
}

// optional .MIDIButtonProto toggle_auto_gain_staging = 10;
inline bool MIDIMappingBusProto::has_toggle_auto_gain_staging() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.toggle_auto_gain_staging_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_toggle_auto_gain_staging() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.toggle_auto_gain_staging_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::toggle_auto_gain_staging() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.toggle_auto_gain_staging)
  return _internal_toggle_auto_gain_staging();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_toggle_auto_gain_staging(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.toggle_auto_gain_staging_);
  }
  _impl_.toggle_auto_gain_staging_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingBusProto.toggle_auto_gain_staging)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_toggle_auto_gain_staging() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::MIDIButtonProto* released = _impl_.toggle_auto_gain_staging_;
  _impl_.toggle_auto_gain_staging_ = 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 MIDIMappingBusProto::unsafe_arena_release_toggle_auto_gain_staging() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.toggle_auto_gain_staging)

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::MIDIButtonProto* temp = _impl_.toggle_auto_gain_staging_;
  _impl_.toggle_auto_gain_staging_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_toggle_auto_gain_staging() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.toggle_auto_gain_staging_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.toggle_auto_gain_staging_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.toggle_auto_gain_staging_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_toggle_auto_gain_staging()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::MIDIButtonProto* _msg = _internal_mutable_toggle_auto_gain_staging();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.toggle_auto_gain_staging)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_toggle_auto_gain_staging(::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_auto_gain_staging_);
  }

  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_.toggle_auto_gain_staging_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.toggle_auto_gain_staging)
}

// optional .MIDIButtonProto toggle_compressor = 11;
inline bool MIDIMappingBusProto::has_toggle_compressor() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  PROTOBUF_ASSUME(!value || _impl_.toggle_compressor_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_toggle_compressor() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.toggle_compressor_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::toggle_compressor() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.toggle_compressor)
  return _internal_toggle_compressor();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_toggle_compressor(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.toggle_compressor_);
  }
  _impl_.toggle_compressor_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingBusProto.toggle_compressor)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_toggle_compressor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::MIDIButtonProto* released = _impl_.toggle_compressor_;
  _impl_.toggle_compressor_ = 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 MIDIMappingBusProto::unsafe_arena_release_toggle_compressor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.toggle_compressor)

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::MIDIButtonProto* temp = _impl_.toggle_compressor_;
  _impl_.toggle_compressor_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_toggle_compressor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.toggle_compressor_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.toggle_compressor_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.toggle_compressor_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_toggle_compressor()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::MIDIButtonProto* _msg = _internal_mutable_toggle_compressor();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.toggle_compressor)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_toggle_compressor(::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_compressor_);
  }

  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_.toggle_compressor_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.toggle_compressor)
}

// optional .MIDIButtonProto clear_peak = 12;
inline bool MIDIMappingBusProto::has_clear_peak() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  PROTOBUF_ASSUME(!value || _impl_.clear_peak_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_clear_peak() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.clear_peak_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::clear_peak() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.clear_peak)
  return _internal_clear_peak();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_clear_peak(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.clear_peak_);
  }
  _impl_.clear_peak_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingBusProto.clear_peak)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_clear_peak() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::MIDIButtonProto* released = _impl_.clear_peak_;
  _impl_.clear_peak_ = 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 MIDIMappingBusProto::unsafe_arena_release_clear_peak() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.clear_peak)

  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::MIDIButtonProto* temp = _impl_.clear_peak_;
  _impl_.clear_peak_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_clear_peak() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.clear_peak_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.clear_peak_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.clear_peak_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_clear_peak()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::MIDIButtonProto* _msg = _internal_mutable_clear_peak();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.clear_peak)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_clear_peak(::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_.clear_peak_);
  }

  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_.clear_peak_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.clear_peak)
}

// optional .MIDIButtonProto prev_bank = 13;
inline bool MIDIMappingBusProto::has_prev_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  PROTOBUF_ASSUME(!value || _impl_.prev_bank_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::prev_bank() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.prev_bank)
  return _internal_prev_bank();
}
inline void MIDIMappingBusProto::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], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.prev_bank)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_prev_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_prev_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.prev_bank)

  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::MIDIButtonProto* temp = _impl_.prev_bank_;
  _impl_.prev_bank_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_prev_bank()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::MIDIButtonProto* _msg = _internal_mutable_prev_bank();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.prev_bank)
  return _msg;
}
inline void MIDIMappingBusProto::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], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  }

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

// optional .MIDIButtonProto next_bank = 14;
inline bool MIDIMappingBusProto::has_next_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  PROTOBUF_ASSUME(!value || _impl_.next_bank_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::next_bank() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.next_bank)
  return _internal_next_bank();
}
inline void MIDIMappingBusProto::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], 0x00001000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.next_bank)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_next_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_next_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.next_bank)

  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::MIDIButtonProto* temp = _impl_.next_bank_;
  _impl_.next_bank_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_next_bank()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::MIDIButtonProto* _msg = _internal_mutable_next_bank();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.next_bank)
  return _msg;
}
inline void MIDIMappingBusProto::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], 0x00001000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  }

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

// optional .MIDIButtonProto select_bank_1 = 15;
inline bool MIDIMappingBusProto::has_select_bank_1() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  PROTOBUF_ASSUME(!value || _impl_.select_bank_1_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::select_bank_1() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.select_bank_1)
  return _internal_select_bank_1();
}
inline void MIDIMappingBusProto::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], 0x00002000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.select_bank_1)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_select_bank_1() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_select_bank_1() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.select_bank_1)

  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::MIDIButtonProto* temp = _impl_.select_bank_1_;
  _impl_.select_bank_1_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_select_bank_1()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::MIDIButtonProto* _msg = _internal_mutable_select_bank_1();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.select_bank_1)
  return _msg;
}
inline void MIDIMappingBusProto::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], 0x00002000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  }

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

// optional .MIDIButtonProto select_bank_2 = 16;
inline bool MIDIMappingBusProto::has_select_bank_2() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  PROTOBUF_ASSUME(!value || _impl_.select_bank_2_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::select_bank_2() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.select_bank_2)
  return _internal_select_bank_2();
}
inline void MIDIMappingBusProto::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], 0x00004000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.select_bank_2)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_select_bank_2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_select_bank_2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.select_bank_2)

  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::MIDIButtonProto* temp = _impl_.select_bank_2_;
  _impl_.select_bank_2_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_select_bank_2()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::MIDIButtonProto* _msg = _internal_mutable_select_bank_2();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.select_bank_2)
  return _msg;
}
inline void MIDIMappingBusProto::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], 0x00004000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  }

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

// optional .MIDIButtonProto select_bank_3 = 17;
inline bool MIDIMappingBusProto::has_select_bank_3() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00008000U);
  PROTOBUF_ASSUME(!value || _impl_.select_bank_3_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::select_bank_3() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.select_bank_3)
  return _internal_select_bank_3();
}
inline void MIDIMappingBusProto::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], 0x00008000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.select_bank_3)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_select_bank_3() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_select_bank_3() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.select_bank_3)

  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  ::MIDIButtonProto* temp = _impl_.select_bank_3_;
  _impl_.select_bank_3_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_select_bank_3()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  ::MIDIButtonProto* _msg = _internal_mutable_select_bank_3();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.select_bank_3)
  return _msg;
}
inline void MIDIMappingBusProto::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], 0x00008000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  }

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

// optional .MIDIButtonProto select_bank_4 = 18;
inline bool MIDIMappingBusProto::has_select_bank_4() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00010000U);
  PROTOBUF_ASSUME(!value || _impl_.select_bank_4_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::select_bank_4() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.select_bank_4)
  return _internal_select_bank_4();
}
inline void MIDIMappingBusProto::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], 0x00010000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.select_bank_4)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_select_bank_4() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_select_bank_4() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.select_bank_4)

  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  ::MIDIButtonProto* temp = _impl_.select_bank_4_;
  _impl_.select_bank_4_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_select_bank_4()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  ::MIDIButtonProto* _msg = _internal_mutable_select_bank_4();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.select_bank_4)
  return _msg;
}
inline void MIDIMappingBusProto::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], 0x00010000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  }

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

// optional .MIDIButtonProto select_bank_5 = 19;
inline bool MIDIMappingBusProto::has_select_bank_5() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00020000U);
  PROTOBUF_ASSUME(!value || _impl_.select_bank_5_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::select_bank_5() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.select_bank_5)
  return _internal_select_bank_5();
}
inline void MIDIMappingBusProto::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], 0x00020000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.select_bank_5)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_select_bank_5() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_select_bank_5() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.select_bank_5)

  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
  ::MIDIButtonProto* temp = _impl_.select_bank_5_;
  _impl_.select_bank_5_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_select_bank_5()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  ::MIDIButtonProto* _msg = _internal_mutable_select_bank_5();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.select_bank_5)
  return _msg;
}
inline void MIDIMappingBusProto::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], 0x00020000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
  }

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

// optional .MIDIButtonProto toggle_limiter = 20;
inline bool MIDIMappingBusProto::has_toggle_limiter() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00040000U);
  PROTOBUF_ASSUME(!value || _impl_.toggle_limiter_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_toggle_limiter() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.toggle_limiter_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::toggle_limiter() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.toggle_limiter)
  return _internal_toggle_limiter();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_toggle_limiter(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.toggle_limiter_);
  }
  _impl_.toggle_limiter_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingBusProto.toggle_limiter)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_toggle_limiter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
  ::MIDIButtonProto* released = _impl_.toggle_limiter_;
  _impl_.toggle_limiter_ = 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 MIDIMappingBusProto::unsafe_arena_release_toggle_limiter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.toggle_limiter)

  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
  ::MIDIButtonProto* temp = _impl_.toggle_limiter_;
  _impl_.toggle_limiter_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_toggle_limiter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.toggle_limiter_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.toggle_limiter_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.toggle_limiter_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_toggle_limiter()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  ::MIDIButtonProto* _msg = _internal_mutable_toggle_limiter();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.toggle_limiter)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_toggle_limiter(::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_limiter_);
  }

  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_.toggle_limiter_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.toggle_limiter)
}

// optional .MIDIButtonProto toggle_auto_makeup_gain = 21;
inline bool MIDIMappingBusProto::has_toggle_auto_makeup_gain() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00080000U);
  PROTOBUF_ASSUME(!value || _impl_.toggle_auto_makeup_gain_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_toggle_auto_makeup_gain() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.toggle_auto_makeup_gain_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::toggle_auto_makeup_gain() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.toggle_auto_makeup_gain)
  return _internal_toggle_auto_makeup_gain();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_toggle_auto_makeup_gain(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.toggle_auto_makeup_gain_);
  }
  _impl_.toggle_auto_makeup_gain_ = 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:MIDIMappingBusProto.toggle_auto_makeup_gain)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_toggle_auto_makeup_gain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
  ::MIDIButtonProto* released = _impl_.toggle_auto_makeup_gain_;
  _impl_.toggle_auto_makeup_gain_ = 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 MIDIMappingBusProto::unsafe_arena_release_toggle_auto_makeup_gain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.toggle_auto_makeup_gain)

  ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
  ::MIDIButtonProto* temp = _impl_.toggle_auto_makeup_gain_;
  _impl_.toggle_auto_makeup_gain_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_toggle_auto_makeup_gain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.toggle_auto_makeup_gain_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.toggle_auto_makeup_gain_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.toggle_auto_makeup_gain_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_toggle_auto_makeup_gain()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  ::MIDIButtonProto* _msg = _internal_mutable_toggle_auto_makeup_gain();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.toggle_auto_makeup_gain)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_toggle_auto_makeup_gain(::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_auto_makeup_gain_);
  }

  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_.toggle_auto_makeup_gain_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.toggle_auto_makeup_gain)
}

// optional .MIDIButtonProto switch_video_channel = 38;
inline bool MIDIMappingBusProto::has_switch_video_channel() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.switch_video_channel_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_switch_video_channel() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.switch_video_channel_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::switch_video_channel() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.switch_video_channel)
  return _internal_switch_video_channel();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_switch_video_channel(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.switch_video_channel_);
  }
  _impl_.switch_video_channel_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingBusProto.switch_video_channel)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_switch_video_channel() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000010U);
  ::MIDIButtonProto* released = _impl_.switch_video_channel_;
  _impl_.switch_video_channel_ = 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 MIDIMappingBusProto::unsafe_arena_release_switch_video_channel() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.switch_video_channel)

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

  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_.switch_video_channel_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.switch_video_channel)
}

// optional .MIDIButtonProto apply_transition = 39;
inline bool MIDIMappingBusProto::has_apply_transition() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000020U);
  PROTOBUF_ASSUME(!value || _impl_.apply_transition_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_apply_transition() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.apply_transition_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::apply_transition() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.apply_transition)
  return _internal_apply_transition();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_apply_transition(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.apply_transition_);
  }
  _impl_.apply_transition_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingBusProto.apply_transition)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_apply_transition() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000020U);
  ::MIDIButtonProto* released = _impl_.apply_transition_;
  _impl_.apply_transition_ = 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 MIDIMappingBusProto::unsafe_arena_release_apply_transition() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.apply_transition)

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

  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_.apply_transition_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.apply_transition)
}

// optional .MIDIButtonProto prev_audio_view = 40;
inline bool MIDIMappingBusProto::has_prev_audio_view() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000040U);
  PROTOBUF_ASSUME(!value || _impl_.prev_audio_view_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_prev_audio_view() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.prev_audio_view_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::prev_audio_view() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.prev_audio_view)
  return _internal_prev_audio_view();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_prev_audio_view(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.prev_audio_view_);
  }
  _impl_.prev_audio_view_ = 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:MIDIMappingBusProto.prev_audio_view)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_prev_audio_view() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

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

  ClearHasBit(_impl_._has_bits_[1], 0x00000040U);
  ::MIDIButtonProto* temp = _impl_.prev_audio_view_;
  _impl_.prev_audio_view_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_prev_audio_view() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.prev_audio_view_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.prev_audio_view_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.prev_audio_view_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_prev_audio_view()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000040U);
  ::MIDIButtonProto* _msg = _internal_mutable_prev_audio_view();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.prev_audio_view)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_prev_audio_view(::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_audio_view_);
  }

  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_.prev_audio_view_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.prev_audio_view)
}

// optional .MIDIButtonProto next_audio_view = 41;
inline bool MIDIMappingBusProto::has_next_audio_view() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000080U);
  PROTOBUF_ASSUME(!value || _impl_.next_audio_view_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_next_audio_view() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.next_audio_view_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::next_audio_view() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.next_audio_view)
  return _internal_next_audio_view();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_next_audio_view(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.next_audio_view_);
  }
  _impl_.next_audio_view_ = reinterpret_cast<::MIDIButtonProto*>(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:MIDIMappingBusProto.next_audio_view)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_next_audio_view() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000080U);
  ::MIDIButtonProto* released = _impl_.next_audio_view_;
  _impl_.next_audio_view_ = 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 MIDIMappingBusProto::unsafe_arena_release_next_audio_view() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.next_audio_view)

  ClearHasBit(_impl_._has_bits_[1], 0x00000080U);
  ::MIDIButtonProto* temp = _impl_.next_audio_view_;
  _impl_.next_audio_view_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_next_audio_view() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.next_audio_view_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.next_audio_view_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.next_audio_view_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_next_audio_view()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000080U);
  ::MIDIButtonProto* _msg = _internal_mutable_next_audio_view();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.next_audio_view)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_next_audio_view(::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_audio_view_);
  }

  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_audio_view_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.next_audio_view)
}

// optional .MIDIButtonProto begin_new_video_segment = 42;
inline bool MIDIMappingBusProto::has_begin_new_video_segment() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.begin_new_video_segment_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_begin_new_video_segment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.begin_new_video_segment_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::begin_new_video_segment() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.begin_new_video_segment)
  return _internal_begin_new_video_segment();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_begin_new_video_segment(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.begin_new_video_segment_);
  }
  _impl_.begin_new_video_segment_ = reinterpret_cast<::MIDIButtonProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000100U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.begin_new_video_segment)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_begin_new_video_segment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000100U);
  ::MIDIButtonProto* released = _impl_.begin_new_video_segment_;
  _impl_.begin_new_video_segment_ = 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 MIDIMappingBusProto::unsafe_arena_release_begin_new_video_segment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.begin_new_video_segment)

  ClearHasBit(_impl_._has_bits_[1], 0x00000100U);
  ::MIDIButtonProto* temp = _impl_.begin_new_video_segment_;
  _impl_.begin_new_video_segment_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_begin_new_video_segment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.begin_new_video_segment_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.begin_new_video_segment_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.begin_new_video_segment_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_begin_new_video_segment()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000100U);
  ::MIDIButtonProto* _msg = _internal_mutable_begin_new_video_segment();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.begin_new_video_segment)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_begin_new_video_segment(::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_.begin_new_video_segment_);
  }

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

  _impl_.begin_new_video_segment_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.begin_new_video_segment)
}

// optional .MIDIButtonProto exit = 43;
inline bool MIDIMappingBusProto::has_exit() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000200U);
  PROTOBUF_ASSUME(!value || _impl_.exit_ != nullptr);
  return value;
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::_internal_exit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIButtonProto* p = _impl_.exit_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIButtonProto>(&::MIDIButtonProto_globals_);
}
inline const ::MIDIButtonProto& MIDIMappingBusProto::exit() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.exit)
  return _internal_exit();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_exit(
    ::MIDIButtonProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.exit_);
  }
  _impl_.exit_ = reinterpret_cast<::MIDIButtonProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000200U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.exit)
}
inline ::MIDIButtonProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_exit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000200U);
  ::MIDIButtonProto* released = _impl_.exit_;
  _impl_.exit_ = 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 MIDIMappingBusProto::unsafe_arena_release_exit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.exit)

  ClearHasBit(_impl_._has_bits_[1], 0x00000200U);
  ::MIDIButtonProto* temp = _impl_.exit_;
  _impl_.exit_ = nullptr;
  return temp;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_exit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.exit_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIButtonProto>(GetArena());
    _impl_.exit_ = reinterpret_cast<::MIDIButtonProto*>(p);
  }
  return _impl_.exit_;
}
inline ::MIDIButtonProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_exit()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000200U);
  ::MIDIButtonProto* _msg = _internal_mutable_exit();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.exit)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_exit(::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_.exit_);
  }

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

  _impl_.exit_ = reinterpret_cast<::MIDIButtonProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.exit)
}

// optional .MIDIControllerProto locut = 22;
inline bool MIDIMappingBusProto::has_locut() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00100000U);
  PROTOBUF_ASSUME(!value || _impl_.locut_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::_internal_locut() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.locut_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::locut() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.locut)
  return _internal_locut();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_locut(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.locut_);
  }
  _impl_.locut_ = reinterpret_cast<::MIDIControllerProto*>(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:MIDIMappingBusProto.locut)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_locut() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
  ::MIDIControllerProto* released = _impl_.locut_;
  _impl_.locut_ = 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 MIDIMappingBusProto::unsafe_arena_release_locut() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.locut)

  ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
  ::MIDIControllerProto* temp = _impl_.locut_;
  _impl_.locut_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_locut() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.locut_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.locut_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.locut_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_locut()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  ::MIDIControllerProto* _msg = _internal_mutable_locut();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.locut)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_locut(::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_.locut_);
  }

  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_.locut_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.locut)
}

// optional .MIDIControllerProto limiter_threshold = 23;
inline bool MIDIMappingBusProto::has_limiter_threshold() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00200000U);
  PROTOBUF_ASSUME(!value || _impl_.limiter_threshold_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::_internal_limiter_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.limiter_threshold_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::limiter_threshold() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.limiter_threshold)
  return _internal_limiter_threshold();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_limiter_threshold(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.limiter_threshold_);
  }
  _impl_.limiter_threshold_ = reinterpret_cast<::MIDIControllerProto*>(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:MIDIMappingBusProto.limiter_threshold)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_limiter_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
  ::MIDIControllerProto* released = _impl_.limiter_threshold_;
  _impl_.limiter_threshold_ = 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 MIDIMappingBusProto::unsafe_arena_release_limiter_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.limiter_threshold)

  ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
  ::MIDIControllerProto* temp = _impl_.limiter_threshold_;
  _impl_.limiter_threshold_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_limiter_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.limiter_threshold_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.limiter_threshold_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.limiter_threshold_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_limiter_threshold()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  ::MIDIControllerProto* _msg = _internal_mutable_limiter_threshold();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.limiter_threshold)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_limiter_threshold(::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_.limiter_threshold_);
  }

  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_.limiter_threshold_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.limiter_threshold)
}

// optional .MIDIControllerProto makeup_gain = 24;
inline bool MIDIMappingBusProto::has_makeup_gain() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00400000U);
  PROTOBUF_ASSUME(!value || _impl_.makeup_gain_ != nullptr);
  return value;
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::_internal_makeup_gain() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDIControllerProto* p = _impl_.makeup_gain_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDIControllerProto>(&::MIDIControllerProto_globals_);
}
inline const ::MIDIControllerProto& MIDIMappingBusProto::makeup_gain() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.makeup_gain)
  return _internal_makeup_gain();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_makeup_gain(
    ::MIDIControllerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.makeup_gain_);
  }
  _impl_.makeup_gain_ = reinterpret_cast<::MIDIControllerProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.makeup_gain)
}
inline ::MIDIControllerProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_makeup_gain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
  ::MIDIControllerProto* released = _impl_.makeup_gain_;
  _impl_.makeup_gain_ = 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 MIDIMappingBusProto::unsafe_arena_release_makeup_gain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.makeup_gain)

  ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
  ::MIDIControllerProto* temp = _impl_.makeup_gain_;
  _impl_.makeup_gain_ = nullptr;
  return temp;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_makeup_gain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.makeup_gain_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDIControllerProto>(GetArena());
    _impl_.makeup_gain_ = reinterpret_cast<::MIDIControllerProto*>(p);
  }
  return _impl_.makeup_gain_;
}
inline ::MIDIControllerProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_makeup_gain()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  ::MIDIControllerProto* _msg = _internal_mutable_makeup_gain();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.makeup_gain)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_makeup_gain(::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_.makeup_gain_);
  }

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

  _impl_.makeup_gain_ = reinterpret_cast<::MIDIControllerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.makeup_gain)
}

// optional .MIDILightProto is_muted = 25;
inline bool MIDIMappingBusProto::has_is_muted() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00800000U);
  PROTOBUF_ASSUME(!value || _impl_.is_muted_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_internal_is_muted() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.is_muted_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingBusProto::is_muted() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.is_muted)
  return _internal_is_muted();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_is_muted(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.is_muted_);
  }
  _impl_.is_muted_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.is_muted)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_is_muted() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
  ::MIDILightProto* released = _impl_.is_muted_;
  _impl_.is_muted_ = 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 MIDIMappingBusProto::unsafe_arena_release_is_muted() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.is_muted)

  ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
  ::MIDILightProto* temp = _impl_.is_muted_;
  _impl_.is_muted_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_is_muted() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.is_muted_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.is_muted_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.is_muted_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_is_muted()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  ::MIDILightProto* _msg = _internal_mutable_is_muted();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.is_muted)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_is_muted(::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_muted_);
  }

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

  _impl_.is_muted_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.is_muted)
}

// optional .MIDILightProto locut_is_on = 26;
inline bool MIDIMappingBusProto::has_locut_is_on() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x01000000U);
  PROTOBUF_ASSUME(!value || _impl_.locut_is_on_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_internal_locut_is_on() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.locut_is_on_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingBusProto::locut_is_on() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.locut_is_on)
  return _internal_locut_is_on();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_locut_is_on(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.locut_is_on_);
  }
  _impl_.locut_is_on_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.locut_is_on)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_locut_is_on() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
  ::MIDILightProto* released = _impl_.locut_is_on_;
  _impl_.locut_is_on_ = 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 MIDIMappingBusProto::unsafe_arena_release_locut_is_on() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.locut_is_on)

  ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
  ::MIDILightProto* temp = _impl_.locut_is_on_;
  _impl_.locut_is_on_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_locut_is_on() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.locut_is_on_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.locut_is_on_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.locut_is_on_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_locut_is_on()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  ::MIDILightProto* _msg = _internal_mutable_locut_is_on();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.locut_is_on)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_locut_is_on(::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_.locut_is_on_);
  }

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

  _impl_.locut_is_on_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.locut_is_on)
}

// optional .MIDILightProto auto_gain_staging_is_on = 27;
inline bool MIDIMappingBusProto::has_auto_gain_staging_is_on() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x02000000U);
  PROTOBUF_ASSUME(!value || _impl_.auto_gain_staging_is_on_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_internal_auto_gain_staging_is_on() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.auto_gain_staging_is_on_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingBusProto::auto_gain_staging_is_on() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.auto_gain_staging_is_on)
  return _internal_auto_gain_staging_is_on();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_auto_gain_staging_is_on(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.auto_gain_staging_is_on_);
  }
  _impl_.auto_gain_staging_is_on_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x02000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x02000000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.auto_gain_staging_is_on)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_auto_gain_staging_is_on() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x02000000U);
  ::MIDILightProto* released = _impl_.auto_gain_staging_is_on_;
  _impl_.auto_gain_staging_is_on_ = 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 MIDIMappingBusProto::unsafe_arena_release_auto_gain_staging_is_on() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.auto_gain_staging_is_on)

  ClearHasBit(_impl_._has_bits_[0], 0x02000000U);
  ::MIDILightProto* temp = _impl_.auto_gain_staging_is_on_;
  _impl_.auto_gain_staging_is_on_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_auto_gain_staging_is_on() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.auto_gain_staging_is_on_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.auto_gain_staging_is_on_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.auto_gain_staging_is_on_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_auto_gain_staging_is_on()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x02000000U);
  ::MIDILightProto* _msg = _internal_mutable_auto_gain_staging_is_on();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.auto_gain_staging_is_on)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_auto_gain_staging_is_on(::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_.auto_gain_staging_is_on_);
  }

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

  _impl_.auto_gain_staging_is_on_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.auto_gain_staging_is_on)
}

// optional .MIDILightProto compressor_is_on = 28;
inline bool MIDIMappingBusProto::has_compressor_is_on() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x04000000U);
  PROTOBUF_ASSUME(!value || _impl_.compressor_is_on_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_internal_compressor_is_on() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.compressor_is_on_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingBusProto::compressor_is_on() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.compressor_is_on)
  return _internal_compressor_is_on();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_compressor_is_on(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.compressor_is_on_);
  }
  _impl_.compressor_is_on_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x04000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x04000000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.compressor_is_on)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_compressor_is_on() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x04000000U);
  ::MIDILightProto* released = _impl_.compressor_is_on_;
  _impl_.compressor_is_on_ = 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 MIDIMappingBusProto::unsafe_arena_release_compressor_is_on() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.compressor_is_on)

  ClearHasBit(_impl_._has_bits_[0], 0x04000000U);
  ::MIDILightProto* temp = _impl_.compressor_is_on_;
  _impl_.compressor_is_on_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_compressor_is_on() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.compressor_is_on_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.compressor_is_on_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.compressor_is_on_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_compressor_is_on()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x04000000U);
  ::MIDILightProto* _msg = _internal_mutable_compressor_is_on();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.compressor_is_on)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_compressor_is_on(::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_.compressor_is_on_);
  }

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

  _impl_.compressor_is_on_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.compressor_is_on)
}

// optional .MIDILightProto has_peaked = 29;
inline bool MIDIMappingBusProto::has_has_peaked() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x08000000U);
  PROTOBUF_ASSUME(!value || _impl_.has_peaked_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_internal_has_peaked() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.has_peaked_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingBusProto::has_peaked() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.has_peaked)
  return _internal_has_peaked();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_has_peaked(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.has_peaked_);
  }
  _impl_.has_peaked_ = reinterpret_cast<::MIDILightProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x08000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x08000000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.has_peaked)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_has_peaked() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x08000000U);
  ::MIDILightProto* released = _impl_.has_peaked_;
  _impl_.has_peaked_ = 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 MIDIMappingBusProto::unsafe_arena_release_has_peaked() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.has_peaked)

  ClearHasBit(_impl_._has_bits_[0], 0x08000000U);
  ::MIDILightProto* temp = _impl_.has_peaked_;
  _impl_.has_peaked_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::_internal_mutable_has_peaked() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.has_peaked_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::MIDILightProto>(GetArena());
    _impl_.has_peaked_ = reinterpret_cast<::MIDILightProto*>(p);
  }
  return _impl_.has_peaked_;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::mutable_has_peaked()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x08000000U);
  ::MIDILightProto* _msg = _internal_mutable_has_peaked();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.has_peaked)
  return _msg;
}
inline void MIDIMappingBusProto::set_allocated_has_peaked(::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_.has_peaked_);
  }

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

  _impl_.has_peaked_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.has_peaked)
}

// optional .MIDILightProto bank_1_is_selected = 30;
inline bool MIDIMappingBusProto::has_bank_1_is_selected() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x10000000U);
  PROTOBUF_ASSUME(!value || _impl_.bank_1_is_selected_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::bank_1_is_selected() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.bank_1_is_selected)
  return _internal_bank_1_is_selected();
}
inline void MIDIMappingBusProto::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], 0x10000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.bank_1_is_selected)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_bank_1_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_bank_1_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.bank_1_is_selected)

  ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
  ::MIDILightProto* temp = _impl_.bank_1_is_selected_;
  _impl_.bank_1_is_selected_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_bank_1_is_selected()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x10000000U);
  ::MIDILightProto* _msg = _internal_mutable_bank_1_is_selected();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.bank_1_is_selected)
  return _msg;
}
inline void MIDIMappingBusProto::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], 0x10000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
  }

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

// optional .MIDILightProto bank_2_is_selected = 31;
inline bool MIDIMappingBusProto::has_bank_2_is_selected() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x20000000U);
  PROTOBUF_ASSUME(!value || _impl_.bank_2_is_selected_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::bank_2_is_selected() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.bank_2_is_selected)
  return _internal_bank_2_is_selected();
}
inline void MIDIMappingBusProto::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], 0x20000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.bank_2_is_selected)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_bank_2_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_bank_2_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.bank_2_is_selected)

  ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
  ::MIDILightProto* temp = _impl_.bank_2_is_selected_;
  _impl_.bank_2_is_selected_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_bank_2_is_selected()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  ::MIDILightProto* _msg = _internal_mutable_bank_2_is_selected();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.bank_2_is_selected)
  return _msg;
}
inline void MIDIMappingBusProto::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], 0x20000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
  }

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

// optional .MIDILightProto bank_3_is_selected = 32;
inline bool MIDIMappingBusProto::has_bank_3_is_selected() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x40000000U);
  PROTOBUF_ASSUME(!value || _impl_.bank_3_is_selected_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::bank_3_is_selected() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.bank_3_is_selected)
  return _internal_bank_3_is_selected();
}
inline void MIDIMappingBusProto::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], 0x40000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.bank_3_is_selected)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_bank_3_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_bank_3_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.bank_3_is_selected)

  ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
  ::MIDILightProto* temp = _impl_.bank_3_is_selected_;
  _impl_.bank_3_is_selected_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_bank_3_is_selected()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  ::MIDILightProto* _msg = _internal_mutable_bank_3_is_selected();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.bank_3_is_selected)
  return _msg;
}
inline void MIDIMappingBusProto::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], 0x40000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
  }

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

// optional .MIDILightProto bank_4_is_selected = 33;
inline bool MIDIMappingBusProto::has_bank_4_is_selected() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x80000000U);
  PROTOBUF_ASSUME(!value || _impl_.bank_4_is_selected_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::bank_4_is_selected() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.bank_4_is_selected)
  return _internal_bank_4_is_selected();
}
inline void MIDIMappingBusProto::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], 0x80000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.bank_4_is_selected)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_bank_4_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_bank_4_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.bank_4_is_selected)

  ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  ::MIDILightProto* temp = _impl_.bank_4_is_selected_;
  _impl_.bank_4_is_selected_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_bank_4_is_selected()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  ::MIDILightProto* _msg = _internal_mutable_bank_4_is_selected();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.bank_4_is_selected)
  return _msg;
}
inline void MIDIMappingBusProto::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], 0x80000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  }

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

// optional .MIDILightProto bank_5_is_selected = 34;
inline bool MIDIMappingBusProto::has_bank_5_is_selected() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.bank_5_is_selected_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_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& MIDIMappingBusProto::bank_5_is_selected() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.bank_5_is_selected)
  return _internal_bank_5_is_selected();
}
inline void MIDIMappingBusProto::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_[1], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MIDIMappingBusProto.bank_5_is_selected)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_bank_5_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  ::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 MIDIMappingBusProto::unsafe_arena_release_bank_5_is_selected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:MIDIMappingBusProto.bank_5_is_selected)

  ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  ::MIDILightProto* temp = _impl_.bank_5_is_selected_;
  _impl_.bank_5_is_selected_ = nullptr;
  return temp;
}
inline ::MIDILightProto* PROTOBUF_NONNULL MIDIMappingBusProto::_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 MIDIMappingBusProto::mutable_bank_5_is_selected()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  ::MIDILightProto* _msg = _internal_mutable_bank_5_is_selected();
  // @@protoc_insertion_point(field_mutable:MIDIMappingBusProto.bank_5_is_selected)
  return _msg;
}
inline void MIDIMappingBusProto::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_[1], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  }

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

// optional .MIDILightProto limiter_is_on = 35;
inline bool MIDIMappingBusProto::has_limiter_is_on() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.limiter_is_on_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_internal_limiter_is_on() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.limiter_is_on_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingBusProto::limiter_is_on() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.limiter_is_on)
  return _internal_limiter_is_on();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_limiter_is_on(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.limiter_is_on_);
  }
  _impl_.limiter_is_on_ = 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:MIDIMappingBusProto.limiter_is_on)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_limiter_is_on() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

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

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

  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_.limiter_is_on_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.limiter_is_on)
}

// optional .MIDILightProto auto_makeup_gain_is_on = 36;
inline bool MIDIMappingBusProto::has_auto_makeup_gain_is_on() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.auto_makeup_gain_is_on_ != nullptr);
  return value;
}
inline const ::MIDILightProto& MIDIMappingBusProto::_internal_auto_makeup_gain_is_on() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::MIDILightProto* p = _impl_.auto_makeup_gain_is_on_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::MIDILightProto>(&::MIDILightProto_globals_);
}
inline const ::MIDILightProto& MIDIMappingBusProto::auto_makeup_gain_is_on() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingBusProto.auto_makeup_gain_is_on)
  return _internal_auto_makeup_gain_is_on();
}
inline void MIDIMappingBusProto::unsafe_arena_set_allocated_auto_makeup_gain_is_on(
    ::MIDILightProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.auto_makeup_gain_is_on_);
  }
  _impl_.auto_makeup_gain_is_on_ = 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:MIDIMappingBusProto.auto_makeup_gain_is_on)
}
inline ::MIDILightProto* PROTOBUF_NULLABLE MIDIMappingBusProto::release_auto_makeup_gain_is_on() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

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

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

  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_.auto_makeup_gain_is_on_ = reinterpret_cast<::MIDILightProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:MIDIMappingBusProto.auto_makeup_gain_is_on)
}

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

// MIDIMappingProto

// optional int32 num_controller_banks = 1 [default = 0];
inline bool MIDIMappingProto::has_num_controller_banks() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void MIDIMappingProto::clear_num_controller_banks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_controller_banks_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
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], 0x00000002U);
  // @@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 int32 stereo_width_bank = 19;
inline bool MIDIMappingProto::has_stereo_width_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00040000U);
  return value;
}
inline void MIDIMappingProto::clear_stereo_width_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stereo_width_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
}
inline ::int32_t MIDIMappingProto::stereo_width_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.stereo_width_bank)
  return _internal_stereo_width_bank();
}
inline void MIDIMappingProto::set_stereo_width_bank(::int32_t value) {
  _internal_set_stereo_width_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.stereo_width_bank)
}
inline ::int32_t MIDIMappingProto::_internal_stereo_width_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.stereo_width_bank_;
}
inline void MIDIMappingProto::_internal_set_stereo_width_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stereo_width_bank_ = value;
}

// optional int32 treble_bank = 2;
inline bool MIDIMappingProto::has_treble_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void MIDIMappingProto::clear_treble_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.treble_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::int32_t MIDIMappingProto::treble_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.treble_bank)
  return _internal_treble_bank();
}
inline void MIDIMappingProto::set_treble_bank(::int32_t value) {
  _internal_set_treble_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.treble_bank)
}
inline ::int32_t MIDIMappingProto::_internal_treble_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.treble_bank_;
}
inline void MIDIMappingProto::_internal_set_treble_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.treble_bank_ = value;
}

// optional int32 mid_bank = 3;
inline bool MIDIMappingProto::has_mid_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void MIDIMappingProto::clear_mid_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mid_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::int32_t MIDIMappingProto::mid_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.mid_bank)
  return _internal_mid_bank();
}
inline void MIDIMappingProto::set_mid_bank(::int32_t value) {
  _internal_set_mid_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.mid_bank)
}
inline ::int32_t MIDIMappingProto::_internal_mid_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mid_bank_;
}
inline void MIDIMappingProto::_internal_set_mid_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mid_bank_ = value;
}

// optional int32 bass_bank = 4;
inline bool MIDIMappingProto::has_bass_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void MIDIMappingProto::clear_bass_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bass_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline ::int32_t MIDIMappingProto::bass_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.bass_bank)
  return _internal_bass_bank();
}
inline void MIDIMappingProto::set_bass_bank(::int32_t value) {
  _internal_set_bass_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.bass_bank)
}
inline ::int32_t MIDIMappingProto::_internal_bass_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.bass_bank_;
}
inline void MIDIMappingProto::_internal_set_bass_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bass_bank_ = value;
}

// optional int32 gain_bank = 5;
inline bool MIDIMappingProto::has_gain_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void MIDIMappingProto::clear_gain_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gain_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline ::int32_t MIDIMappingProto::gain_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.gain_bank)
  return _internal_gain_bank();
}
inline void MIDIMappingProto::set_gain_bank(::int32_t value) {
  _internal_set_gain_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.gain_bank)
}
inline ::int32_t MIDIMappingProto::_internal_gain_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.gain_bank_;
}
inline void MIDIMappingProto::_internal_set_gain_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gain_bank_ = value;
}

// optional int32 compressor_threshold_bank = 6;
inline bool MIDIMappingProto::has_compressor_threshold_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void MIDIMappingProto::clear_compressor_threshold_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.compressor_threshold_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline ::int32_t MIDIMappingProto::compressor_threshold_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.compressor_threshold_bank)
  return _internal_compressor_threshold_bank();
}
inline void MIDIMappingProto::set_compressor_threshold_bank(::int32_t value) {
  _internal_set_compressor_threshold_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.compressor_threshold_bank)
}
inline ::int32_t MIDIMappingProto::_internal_compressor_threshold_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.compressor_threshold_bank_;
}
inline void MIDIMappingProto::_internal_set_compressor_threshold_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.compressor_threshold_bank_ = value;
}

// optional int32 fader_bank = 7;
inline bool MIDIMappingProto::has_fader_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  return value;
}
inline void MIDIMappingProto::clear_fader_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fader_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline ::int32_t MIDIMappingProto::fader_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.fader_bank)
  return _internal_fader_bank();
}
inline void MIDIMappingProto::set_fader_bank(::int32_t value) {
  _internal_set_fader_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.fader_bank)
}
inline ::int32_t MIDIMappingProto::_internal_fader_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.fader_bank_;
}
inline void MIDIMappingProto::_internal_set_fader_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fader_bank_ = value;
}

// optional int32 toggle_mute_bank = 8;
inline bool MIDIMappingProto::has_toggle_mute_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void MIDIMappingProto::clear_toggle_mute_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_mute_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline ::int32_t MIDIMappingProto::toggle_mute_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.toggle_mute_bank)
  return _internal_toggle_mute_bank();
}
inline void MIDIMappingProto::set_toggle_mute_bank(::int32_t value) {
  _internal_set_toggle_mute_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.toggle_mute_bank)
}
inline ::int32_t MIDIMappingProto::_internal_toggle_mute_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.toggle_mute_bank_;
}
inline void MIDIMappingProto::_internal_set_toggle_mute_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_mute_bank_ = value;
}

// optional int32 toggle_locut_bank = 9;
inline bool MIDIMappingProto::has_toggle_locut_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void MIDIMappingProto::clear_toggle_locut_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_locut_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline ::int32_t MIDIMappingProto::toggle_locut_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.toggle_locut_bank)
  return _internal_toggle_locut_bank();
}
inline void MIDIMappingProto::set_toggle_locut_bank(::int32_t value) {
  _internal_set_toggle_locut_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.toggle_locut_bank)
}
inline ::int32_t MIDIMappingProto::_internal_toggle_locut_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.toggle_locut_bank_;
}
inline void MIDIMappingProto::_internal_set_toggle_locut_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_locut_bank_ = value;
}

// optional int32 toggle_auto_gain_staging_bank = 10;
inline bool MIDIMappingProto::has_toggle_auto_gain_staging_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void MIDIMappingProto::clear_toggle_auto_gain_staging_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_auto_gain_staging_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline ::int32_t MIDIMappingProto::toggle_auto_gain_staging_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.toggle_auto_gain_staging_bank)
  return _internal_toggle_auto_gain_staging_bank();
}
inline void MIDIMappingProto::set_toggle_auto_gain_staging_bank(::int32_t value) {
  _internal_set_toggle_auto_gain_staging_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.toggle_auto_gain_staging_bank)
}
inline ::int32_t MIDIMappingProto::_internal_toggle_auto_gain_staging_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.toggle_auto_gain_staging_bank_;
}
inline void MIDIMappingProto::_internal_set_toggle_auto_gain_staging_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_auto_gain_staging_bank_ = value;
}

// optional int32 toggle_compressor_bank = 11;
inline bool MIDIMappingProto::has_toggle_compressor_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  return value;
}
inline void MIDIMappingProto::clear_toggle_compressor_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_compressor_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline ::int32_t MIDIMappingProto::toggle_compressor_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.toggle_compressor_bank)
  return _internal_toggle_compressor_bank();
}
inline void MIDIMappingProto::set_toggle_compressor_bank(::int32_t value) {
  _internal_set_toggle_compressor_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.toggle_compressor_bank)
}
inline ::int32_t MIDIMappingProto::_internal_toggle_compressor_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.toggle_compressor_bank_;
}
inline void MIDIMappingProto::_internal_set_toggle_compressor_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_compressor_bank_ = value;
}

// optional int32 clear_peak_bank = 12;
inline bool MIDIMappingProto::has_clear_peak_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  return value;
}
inline void MIDIMappingProto::clear_clear_peak_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clear_peak_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline ::int32_t MIDIMappingProto::clear_peak_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.clear_peak_bank)
  return _internal_clear_peak_bank();
}
inline void MIDIMappingProto::set_clear_peak_bank(::int32_t value) {
  _internal_set_clear_peak_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.clear_peak_bank)
}
inline ::int32_t MIDIMappingProto::_internal_clear_peak_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clear_peak_bank_;
}
inline void MIDIMappingProto::_internal_set_clear_peak_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clear_peak_bank_ = value;
}

// optional int32 switch_video_channel_bank = 24;
inline bool MIDIMappingProto::has_switch_video_channel_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00800000U);
  return value;
}
inline void MIDIMappingProto::clear_switch_video_channel_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.switch_video_channel_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
}
inline ::int32_t MIDIMappingProto::switch_video_channel_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.switch_video_channel_bank)
  return _internal_switch_video_channel_bank();
}
inline void MIDIMappingProto::set_switch_video_channel_bank(::int32_t value) {
  _internal_set_switch_video_channel_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.switch_video_channel_bank)
}
inline ::int32_t MIDIMappingProto::_internal_switch_video_channel_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.switch_video_channel_bank_;
}
inline void MIDIMappingProto::_internal_set_switch_video_channel_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.switch_video_channel_bank_ = value;
}

// optional int32 apply_transition_bank = 25;
inline bool MIDIMappingProto::has_apply_transition_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x01000000U);
  return value;
}
inline void MIDIMappingProto::clear_apply_transition_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.apply_transition_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
}
inline ::int32_t MIDIMappingProto::apply_transition_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.apply_transition_bank)
  return _internal_apply_transition_bank();
}
inline void MIDIMappingProto::set_apply_transition_bank(::int32_t value) {
  _internal_set_apply_transition_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.apply_transition_bank)
}
inline ::int32_t MIDIMappingProto::_internal_apply_transition_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.apply_transition_bank_;
}
inline void MIDIMappingProto::_internal_set_apply_transition_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.apply_transition_bank_ = value;
}

// optional int32 locut_bank = 13;
inline bool MIDIMappingProto::has_locut_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  return value;
}
inline void MIDIMappingProto::clear_locut_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.locut_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
}
inline ::int32_t MIDIMappingProto::locut_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.locut_bank)
  return _internal_locut_bank();
}
inline void MIDIMappingProto::set_locut_bank(::int32_t value) {
  _internal_set_locut_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.locut_bank)
}
inline ::int32_t MIDIMappingProto::_internal_locut_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.locut_bank_;
}
inline void MIDIMappingProto::_internal_set_locut_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.locut_bank_ = value;
}

// optional int32 limiter_threshold_bank = 14;
inline bool MIDIMappingProto::has_limiter_threshold_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  return value;
}
inline void MIDIMappingProto::clear_limiter_threshold_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.limiter_threshold_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
}
inline ::int32_t MIDIMappingProto::limiter_threshold_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.limiter_threshold_bank)
  return _internal_limiter_threshold_bank();
}
inline void MIDIMappingProto::set_limiter_threshold_bank(::int32_t value) {
  _internal_set_limiter_threshold_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.limiter_threshold_bank)
}
inline ::int32_t MIDIMappingProto::_internal_limiter_threshold_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.limiter_threshold_bank_;
}
inline void MIDIMappingProto::_internal_set_limiter_threshold_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.limiter_threshold_bank_ = value;
}

// optional int32 makeup_gain_bank = 15;
inline bool MIDIMappingProto::has_makeup_gain_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00008000U);
  return value;
}
inline void MIDIMappingProto::clear_makeup_gain_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.makeup_gain_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
}
inline ::int32_t MIDIMappingProto::makeup_gain_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.makeup_gain_bank)
  return _internal_makeup_gain_bank();
}
inline void MIDIMappingProto::set_makeup_gain_bank(::int32_t value) {
  _internal_set_makeup_gain_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.makeup_gain_bank)
}
inline ::int32_t MIDIMappingProto::_internal_makeup_gain_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.makeup_gain_bank_;
}
inline void MIDIMappingProto::_internal_set_makeup_gain_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.makeup_gain_bank_ = value;
}

// optional int32 toggle_limiter_bank = 16;
inline bool MIDIMappingProto::has_toggle_limiter_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00010000U);
  return value;
}
inline void MIDIMappingProto::clear_toggle_limiter_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_limiter_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
}
inline ::int32_t MIDIMappingProto::toggle_limiter_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.toggle_limiter_bank)
  return _internal_toggle_limiter_bank();
}
inline void MIDIMappingProto::set_toggle_limiter_bank(::int32_t value) {
  _internal_set_toggle_limiter_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.toggle_limiter_bank)
}
inline ::int32_t MIDIMappingProto::_internal_toggle_limiter_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.toggle_limiter_bank_;
}
inline void MIDIMappingProto::_internal_set_toggle_limiter_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_limiter_bank_ = value;
}

// optional int32 toggle_auto_makeup_gain_bank = 17;
inline bool MIDIMappingProto::has_toggle_auto_makeup_gain_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00020000U);
  return value;
}
inline void MIDIMappingProto::clear_toggle_auto_makeup_gain_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_auto_makeup_gain_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
}
inline ::int32_t MIDIMappingProto::toggle_auto_makeup_gain_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.toggle_auto_makeup_gain_bank)
  return _internal_toggle_auto_makeup_gain_bank();
}
inline void MIDIMappingProto::set_toggle_auto_makeup_gain_bank(::int32_t value) {
  _internal_set_toggle_auto_makeup_gain_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.toggle_auto_makeup_gain_bank)
}
inline ::int32_t MIDIMappingProto::_internal_toggle_auto_makeup_gain_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.toggle_auto_makeup_gain_bank_;
}
inline void MIDIMappingProto::_internal_set_toggle_auto_makeup_gain_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.toggle_auto_makeup_gain_bank_ = value;
}

// optional int32 prev_audio_view_bank = 20;
inline bool MIDIMappingProto::has_prev_audio_view_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00080000U);
  return value;
}
inline void MIDIMappingProto::clear_prev_audio_view_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.prev_audio_view_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
}
inline ::int32_t MIDIMappingProto::prev_audio_view_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.prev_audio_view_bank)
  return _internal_prev_audio_view_bank();
}
inline void MIDIMappingProto::set_prev_audio_view_bank(::int32_t value) {
  _internal_set_prev_audio_view_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.prev_audio_view_bank)
}
inline ::int32_t MIDIMappingProto::_internal_prev_audio_view_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.prev_audio_view_bank_;
}
inline void MIDIMappingProto::_internal_set_prev_audio_view_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.prev_audio_view_bank_ = value;
}

// optional int32 next_audio_view_bank = 21;
inline bool MIDIMappingProto::has_next_audio_view_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00100000U);
  return value;
}
inline void MIDIMappingProto::clear_next_audio_view_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.next_audio_view_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
}
inline ::int32_t MIDIMappingProto::next_audio_view_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.next_audio_view_bank)
  return _internal_next_audio_view_bank();
}
inline void MIDIMappingProto::set_next_audio_view_bank(::int32_t value) {
  _internal_set_next_audio_view_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.next_audio_view_bank)
}
inline ::int32_t MIDIMappingProto::_internal_next_audio_view_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.next_audio_view_bank_;
}
inline void MIDIMappingProto::_internal_set_next_audio_view_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.next_audio_view_bank_ = value;
}

// optional int32 begin_new_video_segment_bank = 22;
inline bool MIDIMappingProto::has_begin_new_video_segment_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00200000U);
  return value;
}
inline void MIDIMappingProto::clear_begin_new_video_segment_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.begin_new_video_segment_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
}
inline ::int32_t MIDIMappingProto::begin_new_video_segment_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.begin_new_video_segment_bank)
  return _internal_begin_new_video_segment_bank();
}
inline void MIDIMappingProto::set_begin_new_video_segment_bank(::int32_t value) {
  _internal_set_begin_new_video_segment_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.begin_new_video_segment_bank)
}
inline ::int32_t MIDIMappingProto::_internal_begin_new_video_segment_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.begin_new_video_segment_bank_;
}
inline void MIDIMappingProto::_internal_set_begin_new_video_segment_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.begin_new_video_segment_bank_ = value;
}

// optional int32 exit_bank = 23;
inline bool MIDIMappingProto::has_exit_bank() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00400000U);
  return value;
}
inline void MIDIMappingProto::clear_exit_bank() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exit_bank_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
}
inline ::int32_t MIDIMappingProto::exit_bank() const {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.exit_bank)
  return _internal_exit_bank();
}
inline void MIDIMappingProto::set_exit_bank(::int32_t value) {
  _internal_set_exit_bank(value);
  SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  // @@protoc_insertion_point(field_set:MIDIMappingProto.exit_bank)
}
inline ::int32_t MIDIMappingProto::_internal_exit_bank() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exit_bank_;
}
inline void MIDIMappingProto::_internal_set_exit_bank(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exit_bank_ = value;
}

// repeated .MIDIMappingBusProto bus_mapping = 18;
inline int MIDIMappingProto::_internal_bus_mapping_size() const {
  return _internal_bus_mapping().size();
}
inline int MIDIMappingProto::bus_mapping_size() const {
  return _internal_bus_mapping_size();
}
inline void MIDIMappingProto::clear_bus_mapping() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bus_mapping_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::MIDIMappingBusProto& MIDIMappingProto::bus_mapping(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:MIDIMappingProto.bus_mapping)
  return _internal_bus_mapping().Get(index);
}
inline ::MIDIMappingBusProto* PROTOBUF_NONNULL MIDIMappingProto::mutable_bus_mapping(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:MIDIMappingProto.bus_mapping)
  return _internal_mutable_bus_mapping()->Mutable(index);
}
inline ::MIDIMappingBusProto* PROTOBUF_NONNULL MIDIMappingProto::add_bus_mapping()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::MIDIMappingBusProto* _add =
      _internal_mutable_bus_mapping()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:MIDIMappingProto.bus_mapping)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::MIDIMappingBusProto>& MIDIMappingProto::bus_mapping() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:MIDIMappingProto.bus_mapping)
  return _internal_bus_mapping();
}
inline ::google::protobuf::RepeatedPtrField<::MIDIMappingBusProto>* PROTOBUF_NONNULL
MIDIMappingProto::mutable_bus_mapping() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:MIDIMappingProto.bus_mapping)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_bus_mapping();
}
inline const ::google::protobuf::RepeatedPtrField<::MIDIMappingBusProto>&
MIDIMappingProto::_internal_bus_mapping() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.bus_mapping_;
}
inline ::google::protobuf::RepeatedPtrField<::MIDIMappingBusProto>* PROTOBUF_NONNULL
MIDIMappingProto::_internal_mutable_bus_mapping() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.bus_mapping_;
}

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