mm_driver.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: goby/acomms/protobuf/mm_driver.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto
 
#include <limits>
#include <string>
 
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
 
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.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/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "goby/acomms/protobuf/driver_base.pb.h"
#include "goby/acomms/protobuf/modem_message.pb.h"
#include "goby/protobuf/option_extensions.pb.h"
#include "dccl/option_extensions.pb.h"
#include <boost/units/quantity.hpp>
#include <boost/units/absolute.hpp>
#include <boost/units/dimensionless_type.hpp>
#include <boost/units/make_scaled_unit.hpp>
 
#include <boost/units/systems/si.hpp>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE
 
// Internal implementation detail -- do not use these members.
struct TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
namespace goby {
namespace acomms {
namespace micromodem {
namespace protobuf {
class Config;
struct ConfigDefaultTypeInternal;
extern ConfigDefaultTypeInternal _Config_default_instance_;
class Config_Revision;
struct Config_RevisionDefaultTypeInternal;
extern Config_RevisionDefaultTypeInternal _Config_Revision_default_instance_;
class FMSweepParams;
struct FMSweepParamsDefaultTypeInternal;
extern FMSweepParamsDefaultTypeInternal _FMSweepParams_default_instance_;
class GenericLBLParams;
struct GenericLBLParamsDefaultTypeInternal;
extern GenericLBLParamsDefaultTypeInternal _GenericLBLParams_default_instance_;
class HardwareControl;
struct HardwareControlDefaultTypeInternal;
extern HardwareControlDefaultTypeInternal _HardwareControl_default_instance_;
class HardwareControlCommand;
struct HardwareControlCommandDefaultTypeInternal;
extern HardwareControlCommandDefaultTypeInternal _HardwareControlCommand_default_instance_;
class MMApplicationAck;
struct MMApplicationAckDefaultTypeInternal;
extern MMApplicationAckDefaultTypeInternal _MMApplicationAck_default_instance_;
class MMApplicationAck_AckPart;
struct MMApplicationAck_AckPartDefaultTypeInternal;
extern MMApplicationAck_AckPartDefaultTypeInternal _MMApplicationAck_AckPart_default_instance_;
class MSequenceParams;
struct MSequenceParamsDefaultTypeInternal;
extern MSequenceParamsDefaultTypeInternal _MSequenceParams_default_instance_;
class NarrowBandLBLParams;
struct NarrowBandLBLParamsDefaultTypeInternal;
extern NarrowBandLBLParamsDefaultTypeInternal _NarrowBandLBLParams_default_instance_;
class REMUSLBLParams;
struct REMUSLBLParamsDefaultTypeInternal;
extern REMUSLBLParamsDefaultTypeInternal _REMUSLBLParams_default_instance_;
class RangingReply;
struct RangingReplyDefaultTypeInternal;
extern RangingReplyDefaultTypeInternal _RangingReply_default_instance_;
class ReceiveStatistics;
struct ReceiveStatisticsDefaultTypeInternal;
extern ReceiveStatisticsDefaultTypeInternal _ReceiveStatistics_default_instance_;
class Transmission;
struct TransmissionDefaultTypeInternal;
extern TransmissionDefaultTypeInternal _Transmission_default_instance_;
class TransmitStatistics;
struct TransmitStatisticsDefaultTypeInternal;
extern TransmitStatisticsDefaultTypeInternal _TransmitStatistics_default_instance_;
}  // namespace protobuf
}  // namespace micromodem
}  // namespace acomms
}  // namespace goby
PROTOBUF_NAMESPACE_OPEN
template<> ::goby::acomms::micromodem::protobuf::Config* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::Config>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::Config_Revision* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::Config_Revision>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::FMSweepParams* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::FMSweepParams>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::GenericLBLParams* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::GenericLBLParams>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::HardwareControl* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::HardwareControl>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::HardwareControlCommand* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::HardwareControlCommand>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::MMApplicationAck* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::MMApplicationAck>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::MSequenceParams* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::MSequenceParams>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::NarrowBandLBLParams>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::REMUSLBLParams>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::RangingReply* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::RangingReply>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::ReceiveStatistics* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::ReceiveStatistics>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::Transmission* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::Transmission>(Arena*);
template<> ::goby::acomms::micromodem::protobuf::TransmitStatistics* Arena::CreateMaybeMessage<::goby::acomms::micromodem::protobuf::TransmitStatistics>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace goby {
namespace acomms {
namespace micromodem {
namespace protobuf {
 
enum RangingReply_OWTTAmbiguity : int {
  RangingReply_OWTTAmbiguity_OWTT_EXACT = 1,
  RangingReply_OWTTAmbiguity_OWTT_SECOND_AMBIGUOUS = 2
};
bool RangingReply_OWTTAmbiguity_IsValid(int value);
constexpr RangingReply_OWTTAmbiguity RangingReply_OWTTAmbiguity_OWTTAmbiguity_MIN = RangingReply_OWTTAmbiguity_OWTT_EXACT;
constexpr RangingReply_OWTTAmbiguity RangingReply_OWTTAmbiguity_OWTTAmbiguity_MAX = RangingReply_OWTTAmbiguity_OWTT_SECOND_AMBIGUOUS;
constexpr int RangingReply_OWTTAmbiguity_OWTTAmbiguity_ARRAYSIZE = RangingReply_OWTTAmbiguity_OWTTAmbiguity_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RangingReply_OWTTAmbiguity_descriptor();
template<typename T>
inline const std::string& RangingReply_OWTTAmbiguity_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RangingReply_OWTTAmbiguity>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RangingReply_OWTTAmbiguity_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    RangingReply_OWTTAmbiguity_descriptor(), enum_t_value);
}
inline bool RangingReply_OWTTAmbiguity_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RangingReply_OWTTAmbiguity* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RangingReply_OWTTAmbiguity>(
    RangingReply_OWTTAmbiguity_descriptor(), name, value);
}
enum ClockMode : int {
  INVALID_CLOCK_MODE = -1,
  NO_SYNC_TO_PPS_AND_CCCLK_BAD = 0,
  NO_SYNC_TO_PPS_AND_CCCLK_GOOD = 1,
  SYNC_TO_PPS_AND_CCCLK_BAD = 2,
  SYNC_TO_PPS_AND_CCCLK_GOOD = 3
};
bool ClockMode_IsValid(int value);
constexpr ClockMode ClockMode_MIN = INVALID_CLOCK_MODE;
constexpr ClockMode ClockMode_MAX = SYNC_TO_PPS_AND_CCCLK_GOOD;
constexpr int ClockMode_ARRAYSIZE = ClockMode_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClockMode_descriptor();
template<typename T>
inline const std::string& ClockMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ClockMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ClockMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ClockMode_descriptor(), enum_t_value);
}
inline bool ClockMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClockMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClockMode>(
    ClockMode_descriptor(), name, value);
}
enum PacketType : int {
  PACKET_TYPE_UNKNOWN = -1,
  FSK = 1,
  FSK_MINI = 2,
  PSK = 3,
  PSK_MINI = 4,
  FLEXIBLE_DATA_PACKET = 5
};
bool PacketType_IsValid(int value);
constexpr PacketType PacketType_MIN = PACKET_TYPE_UNKNOWN;
constexpr PacketType PacketType_MAX = FLEXIBLE_DATA_PACKET;
constexpr int PacketType_ARRAYSIZE = PacketType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PacketType_descriptor();
template<typename T>
inline const std::string& PacketType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PacketType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PacketType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PacketType_descriptor(), enum_t_value);
}
inline bool PacketType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PacketType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PacketType>(
    PacketType_descriptor(), name, value);
}
enum ReceiveMode : int {
  INVALID_RECEIVE_MODE = -1,
  RECEIVE_GOOD = 0,
  BAD_CRC = 1,
  PACKET_TIMEOUT = 2
};
bool ReceiveMode_IsValid(int value);
constexpr ReceiveMode ReceiveMode_MIN = INVALID_RECEIVE_MODE;
constexpr ReceiveMode ReceiveMode_MAX = PACKET_TIMEOUT;
constexpr int ReceiveMode_ARRAYSIZE = ReceiveMode_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReceiveMode_descriptor();
template<typename T>
inline const std::string& ReceiveMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ReceiveMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ReceiveMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ReceiveMode_descriptor(), enum_t_value);
}
inline bool ReceiveMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReceiveMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ReceiveMode>(
    ReceiveMode_descriptor(), name, value);
}
enum PSKErrorCode : int {
  INVALID_PSK_ERROR_CODE = -1,
  NO_ERROR = 0,
  BAD_MODULATION_HEADER = 1,
  BAD_CRC_DATA_HEADER = 2,
  BAD_CRC_AT_LEAST_ONE_FRAME = 3,
  ERROR_ACCESSING_COPROC = 4,
  EQUALIZER_TIMEOUT = 5,
  MISSED_START_OF_PSK_PACKET = 6
};
bool PSKErrorCode_IsValid(int value);
constexpr PSKErrorCode PSKErrorCode_MIN = INVALID_PSK_ERROR_CODE;
constexpr PSKErrorCode PSKErrorCode_MAX = MISSED_START_OF_PSK_PACKET;
constexpr int PSKErrorCode_ARRAYSIZE = PSKErrorCode_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PSKErrorCode_descriptor();
template<typename T>
inline const std::string& PSKErrorCode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PSKErrorCode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PSKErrorCode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PSKErrorCode_descriptor(), enum_t_value);
}
inline bool PSKErrorCode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PSKErrorCode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PSKErrorCode>(
    PSKErrorCode_descriptor(), name, value);
}
enum TransmitMode : int {
  INVALID_TRANSMIT_MODE = -1,
  TRANSMIT_SUCCESSFUL = 0,
  FETS_TOO_HOT = 1,
  EXTSYNC_TIMEOUT = 2,
  TX_INHIBITED = 3,
  DATA_TIMEOUT = 4
};
bool TransmitMode_IsValid(int value);
constexpr TransmitMode TransmitMode_MIN = INVALID_TRANSMIT_MODE;
constexpr TransmitMode TransmitMode_MAX = DATA_TIMEOUT;
constexpr int TransmitMode_ARRAYSIZE = TransmitMode_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TransmitMode_descriptor();
template<typename T>
inline const std::string& TransmitMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TransmitMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TransmitMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TransmitMode_descriptor(), enum_t_value);
}
inline bool TransmitMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TransmitMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TransmitMode>(
    TransmitMode_descriptor(), name, value);
}
enum TransmissionType : int {
  BASE_TYPE = 0,
  MICROMODEM_TWO_WAY_PING = 1,
  MICROMODEM_REMUS_LBL_RANGING = 2,
  MICROMODEM_NARROWBAND_LBL_RANGING = 3,
  MICROMODEM_MINI_DATA = 4,
  MICROMODEM_FLEXIBLE_DATA = 5,
  MICROMODEM_HARDWARE_CONTROL = 6,
  MICROMODEM_HARDWARE_CONTROL_REPLY = 7,
  MICROMODEM_GENERIC_LBL_RANGING = 8,
  MICROMODEM_FM_SWEEP = 9,
  MICROMODEM_M_SEQUENCE = 10
};
bool TransmissionType_IsValid(int value);
constexpr TransmissionType TransmissionType_MIN = BASE_TYPE;
constexpr TransmissionType TransmissionType_MAX = MICROMODEM_M_SEQUENCE;
constexpr int TransmissionType_ARRAYSIZE = TransmissionType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TransmissionType_descriptor();
template<typename T>
inline const std::string& TransmissionType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TransmissionType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TransmissionType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TransmissionType_descriptor(), enum_t_value);
}
inline bool TransmissionType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TransmissionType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TransmissionType>(
    TransmissionType_descriptor(), name, value);
}
enum HardwareLine : int {
  MM2_GPIO1 = 5,
  MM2_GPIO2 = 6,
  MM2_GPIO3 = 3,
  MM2_GPIO4 = 2,
  MM2_GPIO5 = 4,
  MM1_EXTSEL1 = 1,
  MM1_EXTSEL2 = 2,
  MM1_GPIO = 3,
  MM1_COM1 = 7,
  MM1_COM2 = 8
};
bool HardwareLine_IsValid(int value);
constexpr HardwareLine HardwareLine_MIN = MM1_EXTSEL1;
constexpr HardwareLine HardwareLine_MAX = MM1_COM2;
constexpr int HardwareLine_ARRAYSIZE = HardwareLine_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HardwareLine_descriptor();
template<typename T>
inline const std::string& HardwareLine_Name(T enum_t_value) {
  static_assert(::std::is_same<T, HardwareLine>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function HardwareLine_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    HardwareLine_descriptor(), enum_t_value);
}
inline bool HardwareLine_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HardwareLine* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HardwareLine>(
    HardwareLine_descriptor(), name, value);
}
enum HardwareControlMode : int {
  READ_LINE = 0,
  SET_VALUE = 1,
  TOGGLE_HIGH = 2,
  TOGGLE_LOW = 3
};
bool HardwareControlMode_IsValid(int value);
constexpr HardwareControlMode HardwareControlMode_MIN = READ_LINE;
constexpr HardwareControlMode HardwareControlMode_MAX = TOGGLE_LOW;
constexpr int HardwareControlMode_ARRAYSIZE = HardwareControlMode_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HardwareControlMode_descriptor();
template<typename T>
inline const std::string& HardwareControlMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, HardwareControlMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function HardwareControlMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    HardwareControlMode_descriptor(), enum_t_value);
}
inline bool HardwareControlMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HardwareControlMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HardwareControlMode>(
    HardwareControlMode_descriptor(), name, value);
}
enum HardwareControlArgument : int {
  MODE1_OFF = 0,
  MODE1_ON = 1,
  TOGGLE_1MS = 0,
  TOGGLE_HALF_SEC = 1,
  TOGGLE_1_SEC = 2,
  TOGGLE_2_SEC = 3,
  TOGGLE_6_SEC = 4,
  TOGGLE_10_SEC = 5,
  TOGGLE_20_SEC = 6,
  TOGGLE_30_SEC = 7,
  MODE0_ARG = 0
};
bool HardwareControlArgument_IsValid(int value);
constexpr HardwareControlArgument HardwareControlArgument_MIN = MODE1_OFF;
constexpr HardwareControlArgument HardwareControlArgument_MAX = TOGGLE_30_SEC;
constexpr int HardwareControlArgument_ARRAYSIZE = HardwareControlArgument_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HardwareControlArgument_descriptor();
template<typename T>
inline const std::string& HardwareControlArgument_Name(T enum_t_value) {
  static_assert(::std::is_same<T, HardwareControlArgument>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function HardwareControlArgument_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    HardwareControlArgument_descriptor(), enum_t_value);
}
inline bool HardwareControlArgument_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HardwareControlArgument* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HardwareControlArgument>(
    HardwareControlArgument_descriptor(), name, value);
}
// ===================================================================
 
class NarrowBandLBLParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.NarrowBandLBLParams) */ {
 public:
  inline NarrowBandLBLParams() : NarrowBandLBLParams(nullptr) {}
  ~NarrowBandLBLParams() override;
  explicit PROTOBUF_CONSTEXPR NarrowBandLBLParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  NarrowBandLBLParams(const NarrowBandLBLParams& from);
  NarrowBandLBLParams(NarrowBandLBLParams&& from) noexcept
    : NarrowBandLBLParams() {
    *this = ::std::move(from);
  }
 
  inline NarrowBandLBLParams& operator=(const NarrowBandLBLParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline NarrowBandLBLParams& operator=(NarrowBandLBLParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NarrowBandLBLParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const NarrowBandLBLParams* internal_default_instance() {
    return reinterpret_cast<const NarrowBandLBLParams*>(
               &_NarrowBandLBLParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(NarrowBandLBLParams& a, NarrowBandLBLParams& b) {
    a.Swap(&b);
  }
  inline void Swap(NarrowBandLBLParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NarrowBandLBLParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  NarrowBandLBLParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NarrowBandLBLParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NarrowBandLBLParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NarrowBandLBLParams& from) {
    NarrowBandLBLParams::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NarrowBandLBLParams* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.NarrowBandLBLParams";
  }
  protected:
  explicit NarrowBandLBLParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kReceiveFreqFieldNumber = 3,
    kTransmitFreqFieldNumber = 1,
    kTransmitPingMsFieldNumber = 2,
    kReceivePingMsFieldNumber = 4,
    kTurnaroundMsFieldNumber = 5,
    kTransmitFlagFieldNumber = 6,
    kLblMaxRangeFieldNumber = 7,
  };
  // repeated uint32 receive_freq = 3;
  int receive_freq_size() const;
  private:
  int _internal_receive_freq_size() const;
  public:
  void clear_receive_freq();
  private:
  uint32_t _internal_receive_freq(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_receive_freq() const;
  void _internal_add_receive_freq(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_receive_freq();
  public:
  uint32_t receive_freq(int index) const;
  void set_receive_freq(int index, uint32_t value);
  void add_receive_freq(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      receive_freq() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_receive_freq();
 
  // optional uint32 transmit_freq = 1;
  bool has_transmit_freq() const;
  private:
  bool _internal_has_transmit_freq() const;
  public:
  void clear_transmit_freq();
  uint32_t transmit_freq() const;
  void set_transmit_freq(uint32_t value);
  private:
  uint32_t _internal_transmit_freq() const;
  void _internal_set_transmit_freq(uint32_t value);
  public:
 
  // optional uint32 transmit_ping_ms = 2;
  bool has_transmit_ping_ms() const;
  private:
  bool _internal_has_transmit_ping_ms() const;
  public:
  void clear_transmit_ping_ms();
  uint32_t transmit_ping_ms() const;
  void set_transmit_ping_ms(uint32_t value);
  private:
  uint32_t _internal_transmit_ping_ms() const;
  void _internal_set_transmit_ping_ms(uint32_t value);
  public:
 
  // optional uint32 receive_ping_ms = 4;
  bool has_receive_ping_ms() const;
  private:
  bool _internal_has_receive_ping_ms() const;
  public:
  void clear_receive_ping_ms();
  uint32_t receive_ping_ms() const;
  void set_receive_ping_ms(uint32_t value);
  private:
  uint32_t _internal_receive_ping_ms() const;
  void _internal_set_receive_ping_ms(uint32_t value);
  public:
 
  // optional uint32 turnaround_ms = 5;
  bool has_turnaround_ms() const;
  private:
  bool _internal_has_turnaround_ms() const;
  public:
  void clear_turnaround_ms();
  uint32_t turnaround_ms() const;
  void set_turnaround_ms(uint32_t value);
  private:
  uint32_t _internal_turnaround_ms() const;
  void _internal_set_turnaround_ms(uint32_t value);
  public:
 
  // optional bool transmit_flag = 6 [default = true];
  bool has_transmit_flag() const;
  private:
  bool _internal_has_transmit_flag() const;
  public:
  void clear_transmit_flag();
  bool transmit_flag() const;
  void set_transmit_flag(bool value);
  private:
  bool _internal_transmit_flag() const;
  void _internal_set_transmit_flag(bool value);
  public:
 
  // optional uint32 lbl_max_range = 7 [default = 2000];
  bool has_lbl_max_range() const;
  private:
  bool _internal_has_lbl_max_range() const;
  public:
  void clear_lbl_max_range();
  uint32_t lbl_max_range() const;
  void set_lbl_max_range(uint32_t value);
  private:
  uint32_t _internal_lbl_max_range() const;
  void _internal_set_lbl_max_range(uint32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.NarrowBandLBLParams)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > receive_freq_;
    uint32_t transmit_freq_;
    uint32_t transmit_ping_ms_;
    uint32_t receive_ping_ms_;
    uint32_t turnaround_ms_;
    bool transmit_flag_;
    uint32_t lbl_max_range_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class REMUSLBLParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.REMUSLBLParams) */ {
 public:
  inline REMUSLBLParams() : REMUSLBLParams(nullptr) {}
  ~REMUSLBLParams() override;
  explicit PROTOBUF_CONSTEXPR REMUSLBLParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  REMUSLBLParams(const REMUSLBLParams& from);
  REMUSLBLParams(REMUSLBLParams&& from) noexcept
    : REMUSLBLParams() {
    *this = ::std::move(from);
  }
 
  inline REMUSLBLParams& operator=(const REMUSLBLParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline REMUSLBLParams& operator=(REMUSLBLParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const REMUSLBLParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const REMUSLBLParams* internal_default_instance() {
    return reinterpret_cast<const REMUSLBLParams*>(
               &_REMUSLBLParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(REMUSLBLParams& a, REMUSLBLParams& b) {
    a.Swap(&b);
  }
  inline void Swap(REMUSLBLParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(REMUSLBLParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  REMUSLBLParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<REMUSLBLParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const REMUSLBLParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const REMUSLBLParams& from) {
    REMUSLBLParams::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(REMUSLBLParams* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.REMUSLBLParams";
  }
  protected:
  explicit REMUSLBLParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kLblMaxRangeFieldNumber = 3,
    kEnableBeaconsFieldNumber = 1,
    kTurnaroundMsFieldNumber = 2,
  };
  // optional uint32 lbl_max_range = 3 [default = 1000];
  bool has_lbl_max_range() const;
  private:
  bool _internal_has_lbl_max_range() const;
  public:
  void clear_lbl_max_range();
  uint32_t lbl_max_range() const;
  void set_lbl_max_range(uint32_t value);
  private:
  uint32_t _internal_lbl_max_range() const;
  void _internal_set_lbl_max_range(uint32_t value);
  public:
 
  // optional uint32 enable_beacons = 1 [default = 15];
  bool has_enable_beacons() const;
  private:
  bool _internal_has_enable_beacons() const;
  public:
  void clear_enable_beacons();
  uint32_t enable_beacons() const;
  void set_enable_beacons(uint32_t value);
  private:
  uint32_t _internal_enable_beacons() const;
  void _internal_set_enable_beacons(uint32_t value);
  public:
 
  // optional uint32 turnaround_ms = 2 [default = 50];
  bool has_turnaround_ms() const;
  private:
  bool _internal_has_turnaround_ms() const;
  public:
  void clear_turnaround_ms();
  uint32_t turnaround_ms() const;
  void set_turnaround_ms(uint32_t value);
  private:
  uint32_t _internal_turnaround_ms() const;
  void _internal_set_turnaround_ms(uint32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.REMUSLBLParams)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t lbl_max_range_;
    uint32_t enable_beacons_;
    uint32_t turnaround_ms_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class GenericLBLParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.GenericLBLParams) */ {
 public:
  inline GenericLBLParams() : GenericLBLParams(nullptr) {}
  ~GenericLBLParams() override;
  explicit PROTOBUF_CONSTEXPR GenericLBLParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  GenericLBLParams(const GenericLBLParams& from);
  GenericLBLParams(GenericLBLParams&& from) noexcept
    : GenericLBLParams() {
    *this = ::std::move(from);
  }
 
  inline GenericLBLParams& operator=(const GenericLBLParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline GenericLBLParams& operator=(GenericLBLParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const GenericLBLParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const GenericLBLParams* internal_default_instance() {
    return reinterpret_cast<const GenericLBLParams*>(
               &_GenericLBLParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  friend void swap(GenericLBLParams& a, GenericLBLParams& b) {
    a.Swap(&b);
  }
  inline void Swap(GenericLBLParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GenericLBLParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  GenericLBLParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GenericLBLParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GenericLBLParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const GenericLBLParams& from) {
    GenericLBLParams::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GenericLBLParams* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.GenericLBLParams";
  }
  protected:
  explicit GenericLBLParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kReceiveSeqCodeFieldNumber = 5,
    kTransmitFreqFieldNumber = 1,
    kNBitsFieldNumber = 2,
    kTransmitSeqCodeFieldNumber = 3,
    kReceiveFreqFieldNumber = 4,
    kBandwidthFieldNumber = 6,
    kTurnaroundMsFieldNumber = 7,
    kLblMaxRangeFieldNumber = 8,
  };
  // repeated uint64 receive_seq_code = 5;
  int receive_seq_code_size() const;
  private:
  int _internal_receive_seq_code_size() const;
  public:
  void clear_receive_seq_code();
  private:
  uint64_t _internal_receive_seq_code(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      _internal_receive_seq_code() const;
  void _internal_add_receive_seq_code(uint64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      _internal_mutable_receive_seq_code();
  public:
  uint64_t receive_seq_code(int index) const;
  void set_receive_seq_code(int index, uint64_t value);
  void add_receive_seq_code(uint64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      receive_seq_code() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      mutable_receive_seq_code();
 
  // optional uint32 transmit_freq = 1;
  bool has_transmit_freq() const;
  private:
  bool _internal_has_transmit_freq() const;
  public:
  void clear_transmit_freq();
  uint32_t transmit_freq() const;
  void set_transmit_freq(uint32_t value);
  private:
  uint32_t _internal_transmit_freq() const;
  void _internal_set_transmit_freq(uint32_t value);
  public:
 
  // optional uint32 n_bits = 2;
  bool has_n_bits() const;
  private:
  bool _internal_has_n_bits() const;
  public:
  void clear_n_bits();
  uint32_t n_bits() const;
  void set_n_bits(uint32_t value);
  private:
  uint32_t _internal_n_bits() const;
  void _internal_set_n_bits(uint32_t value);
  public:
 
  // optional uint64 transmit_seq_code = 3;
  bool has_transmit_seq_code() const;
  private:
  bool _internal_has_transmit_seq_code() const;
  public:
  void clear_transmit_seq_code();
  uint64_t transmit_seq_code() const;
  void set_transmit_seq_code(uint64_t value);
  private:
  uint64_t _internal_transmit_seq_code() const;
  void _internal_set_transmit_seq_code(uint64_t value);
  public:
 
  // optional uint32 receive_freq = 4;
  bool has_receive_freq() const;
  private:
  bool _internal_has_receive_freq() const;
  public:
  void clear_receive_freq();
  uint32_t receive_freq() const;
  void set_receive_freq(uint32_t value);
  private:
  uint32_t _internal_receive_freq() const;
  void _internal_set_receive_freq(uint32_t value);
  public:
 
  // optional uint32 bandwidth = 6;
  bool has_bandwidth() const;
  private:
  bool _internal_has_bandwidth() const;
  public:
  void clear_bandwidth();
  uint32_t bandwidth() const;
  void set_bandwidth(uint32_t value);
  private:
  uint32_t _internal_bandwidth() const;
  void _internal_set_bandwidth(uint32_t value);
  public:
 
  // optional uint32 turnaround_ms = 7;
  bool has_turnaround_ms() const;
  private:
  bool _internal_has_turnaround_ms() const;
  public:
  void clear_turnaround_ms();
  uint32_t turnaround_ms() const;
  void set_turnaround_ms(uint32_t value);
  private:
  uint32_t _internal_turnaround_ms() const;
  void _internal_set_turnaround_ms(uint32_t value);
  public:
 
  // optional uint32 lbl_max_range = 8 [default = 2000];
  bool has_lbl_max_range() const;
  private:
  bool _internal_has_lbl_max_range() const;
  public:
  void clear_lbl_max_range();
  uint32_t lbl_max_range() const;
  void set_lbl_max_range(uint32_t value);
  private:
  uint32_t _internal_lbl_max_range() const;
  void _internal_set_lbl_max_range(uint32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.GenericLBLParams)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > receive_seq_code_;
    uint32_t transmit_freq_;
    uint32_t n_bits_;
    uint64_t transmit_seq_code_;
    uint32_t receive_freq_;
    uint32_t bandwidth_;
    uint32_t turnaround_ms_;
    uint32_t lbl_max_range_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class FMSweepParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.FMSweepParams) */ {
 public:
  inline FMSweepParams() : FMSweepParams(nullptr) {}
  ~FMSweepParams() override;
  explicit PROTOBUF_CONSTEXPR FMSweepParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  FMSweepParams(const FMSweepParams& from);
  FMSweepParams(FMSweepParams&& from) noexcept
    : FMSweepParams() {
    *this = ::std::move(from);
  }
 
  inline FMSweepParams& operator=(const FMSweepParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline FMSweepParams& operator=(FMSweepParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FMSweepParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const FMSweepParams* internal_default_instance() {
    return reinterpret_cast<const FMSweepParams*>(
               &_FMSweepParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  friend void swap(FMSweepParams& a, FMSweepParams& b) {
    a.Swap(&b);
  }
  inline void Swap(FMSweepParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FMSweepParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  FMSweepParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FMSweepParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FMSweepParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const FMSweepParams& from) {
    FMSweepParams::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FMSweepParams* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.FMSweepParams";
  }
  protected:
  explicit FMSweepParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kStartFreqFieldNumber = 1,
    kStopFreqFieldNumber = 2,
    kDurationMsFieldNumber = 3,
    kNumberRepetitionsFieldNumber = 4,
    kRepetitionPeriodMsFieldNumber = 5,
  };
  // required double start_freq = 1;
  bool has_start_freq() const;
  private:
  bool _internal_has_start_freq() const;
  public:
  void clear_start_freq();
  double start_freq() const;
  void set_start_freq(double value);
  private:
  double _internal_start_freq() const;
  void _internal_set_start_freq(double value);
  public:
 
  // required double stop_freq = 2;
  bool has_stop_freq() const;
  private:
  bool _internal_has_stop_freq() const;
  public:
  void clear_stop_freq();
  double stop_freq() const;
  void set_stop_freq(double value);
  private:
  double _internal_stop_freq() const;
  void _internal_set_stop_freq(double value);
  public:
 
  // required double duration_ms = 3;
  bool has_duration_ms() const;
  private:
  bool _internal_has_duration_ms() const;
  public:
  void clear_duration_ms();
  double duration_ms() const;
  void set_duration_ms(double value);
  private:
  double _internal_duration_ms() const;
  void _internal_set_duration_ms(double value);
  public:
 
  // optional uint32 number_repetitions = 4 [default = 1];
  bool has_number_repetitions() const;
  private:
  bool _internal_has_number_repetitions() const;
  public:
  void clear_number_repetitions();
  uint32_t number_repetitions() const;
  void set_number_repetitions(uint32_t value);
  private:
  uint32_t _internal_number_repetitions() const;
  void _internal_set_number_repetitions(uint32_t value);
  public:
 
  // optional double repetition_period_ms = 5 [default = 1000];
  bool has_repetition_period_ms() const;
  private:
  bool _internal_has_repetition_period_ms() const;
  public:
  void clear_repetition_period_ms();
  double repetition_period_ms() const;
  void set_repetition_period_ms(double value);
  private:
  double _internal_repetition_period_ms() const;
  void _internal_set_repetition_period_ms(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.FMSweepParams)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    double start_freq_;
    double stop_freq_;
    double duration_ms_;
    uint32_t number_repetitions_;
    double repetition_period_ms_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class MSequenceParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.MSequenceParams) */ {
 public:
  inline MSequenceParams() : MSequenceParams(nullptr) {}
  ~MSequenceParams() override;
  explicit PROTOBUF_CONSTEXPR MSequenceParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MSequenceParams(const MSequenceParams& from);
  MSequenceParams(MSequenceParams&& from) noexcept
    : MSequenceParams() {
    *this = ::std::move(from);
  }
 
  inline MSequenceParams& operator=(const MSequenceParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline MSequenceParams& operator=(MSequenceParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MSequenceParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const MSequenceParams* internal_default_instance() {
    return reinterpret_cast<const MSequenceParams*>(
               &_MSequenceParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  friend void swap(MSequenceParams& a, MSequenceParams& b) {
    a.Swap(&b);
  }
  inline void Swap(MSequenceParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MSequenceParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MSequenceParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MSequenceParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MSequenceParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MSequenceParams& from) {
    MSequenceParams::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MSequenceParams* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.MSequenceParams";
  }
  protected:
  explicit MSequenceParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kSeqlenBitsFieldNumber = 1,
    kNumberRepetitionsFieldNumber = 2,
    kCarrierCyclesPerChipFieldNumber = 3,
    kCarrierFreqFieldNumber = 4,
  };
  // required uint32 seqlen_bits = 1;
  bool has_seqlen_bits() const;
  private:
  bool _internal_has_seqlen_bits() const;
  public:
  void clear_seqlen_bits();
  uint32_t seqlen_bits() const;
  void set_seqlen_bits(uint32_t value);
  private:
  uint32_t _internal_seqlen_bits() const;
  void _internal_set_seqlen_bits(uint32_t value);
  public:
 
  // required uint32 number_repetitions = 2;
  bool has_number_repetitions() const;
  private:
  bool _internal_has_number_repetitions() const;
  public:
  void clear_number_repetitions();
  uint32_t number_repetitions() const;
  void set_number_repetitions(uint32_t value);
  private:
  uint32_t _internal_number_repetitions() const;
  void _internal_set_number_repetitions(uint32_t value);
  public:
 
  // required uint32 carrier_cycles_per_chip = 3;
  bool has_carrier_cycles_per_chip() const;
  private:
  bool _internal_has_carrier_cycles_per_chip() const;
  public:
  void clear_carrier_cycles_per_chip();
  uint32_t carrier_cycles_per_chip() const;
  void set_carrier_cycles_per_chip(uint32_t value);
  private:
  uint32_t _internal_carrier_cycles_per_chip() const;
  void _internal_set_carrier_cycles_per_chip(uint32_t value);
  public:
 
  // required uint32 carrier_freq = 4;
  bool has_carrier_freq() const;
  private:
  bool _internal_has_carrier_freq() const;
  public:
  void clear_carrier_freq();
  uint32_t carrier_freq() const;
  void set_carrier_freq(uint32_t value);
  private:
  uint32_t _internal_carrier_freq() const;
  void _internal_set_carrier_freq(uint32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.MSequenceParams)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t seqlen_bits_;
    uint32_t number_repetitions_;
    uint32_t carrier_cycles_per_chip_;
    uint32_t carrier_freq_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class Config_Revision final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.Config.Revision) */ {
 public:
  inline Config_Revision() : Config_Revision(nullptr) {}
  ~Config_Revision() override;
  explicit PROTOBUF_CONSTEXPR Config_Revision(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Config_Revision(const Config_Revision& from);
  Config_Revision(Config_Revision&& from) noexcept
    : Config_Revision() {
    *this = ::std::move(from);
  }
 
  inline Config_Revision& operator=(const Config_Revision& from) {
    CopyFrom(from);
    return *this;
  }
  inline Config_Revision& operator=(Config_Revision&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Config_Revision& default_instance() {
    return *internal_default_instance();
  }
  static inline const Config_Revision* internal_default_instance() {
    return reinterpret_cast<const Config_Revision*>(
               &_Config_Revision_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  friend void swap(Config_Revision& a, Config_Revision& b) {
    a.Swap(&b);
  }
  inline void Swap(Config_Revision* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Config_Revision* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Config_Revision* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Config_Revision>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Config_Revision& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Config_Revision& from) {
    Config_Revision::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Config_Revision* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.Config.Revision";
  }
  protected:
  explicit Config_Revision(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kMmMajorFieldNumber = 1,
    kMmMinorFieldNumber = 2,
    kMmPatchFieldNumber = 3,
  };
  // required int32 mm_major = 1;
  bool has_mm_major() const;
  private:
  bool _internal_has_mm_major() const;
  public:
  void clear_mm_major();
  int32_t mm_major() const;
  void set_mm_major(int32_t value);
  private:
  int32_t _internal_mm_major() const;
  void _internal_set_mm_major(int32_t value);
  public:
 
  // required int32 mm_minor = 2;
  bool has_mm_minor() const;
  private:
  bool _internal_has_mm_minor() const;
  public:
  void clear_mm_minor();
  int32_t mm_minor() const;
  void set_mm_minor(int32_t value);
  private:
  int32_t _internal_mm_minor() const;
  void _internal_set_mm_minor(int32_t value);
  public:
 
  // required int32 mm_patch = 3;
  bool has_mm_patch() const;
  private:
  bool _internal_has_mm_patch() const;
  public:
  void clear_mm_patch();
  int32_t mm_patch() const;
  void set_mm_patch(int32_t value);
  private:
  int32_t _internal_mm_patch() const;
  void _internal_set_mm_patch(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.Config.Revision)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t mm_major_;
    int32_t mm_minor_;
    int32_t mm_patch_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class Config final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.Config) */ {
 public:
  inline Config() : Config(nullptr) {}
  ~Config() override;
  explicit PROTOBUF_CONSTEXPR Config(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Config(const Config& from);
  Config(Config&& from) noexcept
    : Config() {
    *this = ::std::move(from);
  }
 
  inline Config& operator=(const Config& from) {
    CopyFrom(from);
    return *this;
  }
  inline Config& operator=(Config&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Config& default_instance() {
    return *internal_default_instance();
  }
  static inline const Config* internal_default_instance() {
    return reinterpret_cast<const Config*>(
               &_Config_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  friend void swap(Config& a, Config& b) {
    a.Swap(&b);
  }
  inline void Swap(Config* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Config* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Config* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Config>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Config& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Config& from) {
    Config::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Config* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.Config";
  }
  protected:
  explicit Config(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef Config_Revision Revision;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kNvramCfgFieldNumber = 2,
    kAdditionalApplicationAckModemIdFieldNumber = 21,
    kNarrowbandLblFieldNumber = 4,
    kRemusLblFieldNumber = 5,
    kGenericLblFieldNumber = 8,
    kFmSweepFieldNumber = 9,
    kMSequenceFieldNumber = 10,
    kRevisionFieldNumber = 30,
    kHydroidGatewayIdFieldNumber = 3,
    kResetNvramFieldNumber = 1,
    kUseApplicationAcksFieldNumber = 20,
    kPadPartialFramesFieldNumber = 23,
    kUseBase64FdpFieldNumber = 40,
    kQueryCfgOnStartupFieldNumber = 22,
    kKeepAliveSecondsFieldNumber = 6,
    kAllowedSkewMsFieldNumber = 7,
  };
  // repeated string nvram_cfg = 2;
  int nvram_cfg_size() const;
  private:
  int _internal_nvram_cfg_size() const;
  public:
  void clear_nvram_cfg();
  const std::string& nvram_cfg(int index) const;
  std::string* mutable_nvram_cfg(int index);
  void set_nvram_cfg(int index, const std::string& value);
  void set_nvram_cfg(int index, std::string&& value);
  void set_nvram_cfg(int index, const char* value);
  void set_nvram_cfg(int index, const char* value, size_t size);
  std::string* add_nvram_cfg();
  void add_nvram_cfg(const std::string& value);
  void add_nvram_cfg(std::string&& value);
  void add_nvram_cfg(const char* value);
  void add_nvram_cfg(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& nvram_cfg() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_nvram_cfg();
  private:
  const std::string& _internal_nvram_cfg(int index) const;
  std::string* _internal_add_nvram_cfg();
  public:
 
  // repeated uint32 additional_application_ack_modem_id = 21;
  int additional_application_ack_modem_id_size() const;
  private:
  int _internal_additional_application_ack_modem_id_size() const;
  public:
  void clear_additional_application_ack_modem_id();
  private:
  uint32_t _internal_additional_application_ack_modem_id(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_additional_application_ack_modem_id() const;
  void _internal_add_additional_application_ack_modem_id(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_additional_application_ack_modem_id();
  public:
  uint32_t additional_application_ack_modem_id(int index) const;
  void set_additional_application_ack_modem_id(int index, uint32_t value);
  void add_additional_application_ack_modem_id(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      additional_application_ack_modem_id() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_additional_application_ack_modem_id();
 
  // optional .goby.acomms.micromodem.protobuf.NarrowBandLBLParams narrowband_lbl = 4;
  bool has_narrowband_lbl() const;
  private:
  bool _internal_has_narrowband_lbl() const;
  public:
  void clear_narrowband_lbl();
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& narrowband_lbl() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* release_narrowband_lbl();
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* mutable_narrowband_lbl();
  void set_allocated_narrowband_lbl(::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl);
  private:
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& _internal_narrowband_lbl() const;
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* _internal_mutable_narrowband_lbl();
  public:
  void unsafe_arena_set_allocated_narrowband_lbl(
      ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl);
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* unsafe_arena_release_narrowband_lbl();
 
  // optional .goby.acomms.micromodem.protobuf.REMUSLBLParams remus_lbl = 5;
  bool has_remus_lbl() const;
  private:
  bool _internal_has_remus_lbl() const;
  public:
  void clear_remus_lbl();
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& remus_lbl() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::REMUSLBLParams* release_remus_lbl();
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* mutable_remus_lbl();
  void set_allocated_remus_lbl(::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl);
  private:
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& _internal_remus_lbl() const;
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* _internal_mutable_remus_lbl();
  public:
  void unsafe_arena_set_allocated_remus_lbl(
      ::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl);
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* unsafe_arena_release_remus_lbl();
 
  // optional .goby.acomms.micromodem.protobuf.GenericLBLParams generic_lbl = 8;
  bool has_generic_lbl() const;
  private:
  bool _internal_has_generic_lbl() const;
  public:
  void clear_generic_lbl();
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams& generic_lbl() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::GenericLBLParams* release_generic_lbl();
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* mutable_generic_lbl();
  void set_allocated_generic_lbl(::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl);
  private:
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams& _internal_generic_lbl() const;
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* _internal_mutable_generic_lbl();
  public:
  void unsafe_arena_set_allocated_generic_lbl(
      ::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl);
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* unsafe_arena_release_generic_lbl();
 
  // optional .goby.acomms.micromodem.protobuf.FMSweepParams fm_sweep = 9;
  bool has_fm_sweep() const;
  private:
  bool _internal_has_fm_sweep() const;
  public:
  void clear_fm_sweep();
  const ::goby::acomms::micromodem::protobuf::FMSweepParams& fm_sweep() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::FMSweepParams* release_fm_sweep();
  ::goby::acomms::micromodem::protobuf::FMSweepParams* mutable_fm_sweep();
  void set_allocated_fm_sweep(::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep);
  private:
  const ::goby::acomms::micromodem::protobuf::FMSweepParams& _internal_fm_sweep() const;
  ::goby::acomms::micromodem::protobuf::FMSweepParams* _internal_mutable_fm_sweep();
  public:
  void unsafe_arena_set_allocated_fm_sweep(
      ::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep);
  ::goby::acomms::micromodem::protobuf::FMSweepParams* unsafe_arena_release_fm_sweep();
 
  // optional .goby.acomms.micromodem.protobuf.MSequenceParams m_sequence = 10;
  bool has_m_sequence() const;
  private:
  bool _internal_has_m_sequence() const;
  public:
  void clear_m_sequence();
  const ::goby::acomms::micromodem::protobuf::MSequenceParams& m_sequence() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::MSequenceParams* release_m_sequence();
  ::goby::acomms::micromodem::protobuf::MSequenceParams* mutable_m_sequence();
  void set_allocated_m_sequence(::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence);
  private:
  const ::goby::acomms::micromodem::protobuf::MSequenceParams& _internal_m_sequence() const;
  ::goby::acomms::micromodem::protobuf::MSequenceParams* _internal_mutable_m_sequence();
  public:
  void unsafe_arena_set_allocated_m_sequence(
      ::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence);
  ::goby::acomms::micromodem::protobuf::MSequenceParams* unsafe_arena_release_m_sequence();
 
  // optional .goby.acomms.micromodem.protobuf.Config.Revision revision = 30;
  bool has_revision() const;
  private:
  bool _internal_has_revision() const;
  public:
  void clear_revision();
  const ::goby::acomms::micromodem::protobuf::Config_Revision& revision() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::Config_Revision* release_revision();
  ::goby::acomms::micromodem::protobuf::Config_Revision* mutable_revision();
  void set_allocated_revision(::goby::acomms::micromodem::protobuf::Config_Revision* revision);
  private:
  const ::goby::acomms::micromodem::protobuf::Config_Revision& _internal_revision() const;
  ::goby::acomms::micromodem::protobuf::Config_Revision* _internal_mutable_revision();
  public:
  void unsafe_arena_set_allocated_revision(
      ::goby::acomms::micromodem::protobuf::Config_Revision* revision);
  ::goby::acomms::micromodem::protobuf::Config_Revision* unsafe_arena_release_revision();
 
  // optional uint32 hydroid_gateway_id = 3 [default = 0];
  bool has_hydroid_gateway_id() const;
  private:
  bool _internal_has_hydroid_gateway_id() const;
  public:
  void clear_hydroid_gateway_id();
  uint32_t hydroid_gateway_id() const;
  void set_hydroid_gateway_id(uint32_t value);
  private:
  uint32_t _internal_hydroid_gateway_id() const;
  void _internal_set_hydroid_gateway_id(uint32_t value);
  public:
 
  // optional bool reset_nvram = 1 [default = false];
  bool has_reset_nvram() const;
  private:
  bool _internal_has_reset_nvram() const;
  public:
  void clear_reset_nvram();
  bool reset_nvram() const;
  void set_reset_nvram(bool value);
  private:
  bool _internal_reset_nvram() const;
  void _internal_set_reset_nvram(bool value);
  public:
 
  // optional bool use_application_acks = 20 [default = false];
  bool has_use_application_acks() const;
  private:
  bool _internal_has_use_application_acks() const;
  public:
  void clear_use_application_acks();
  bool use_application_acks() const;
  void set_use_application_acks(bool value);
  private:
  bool _internal_use_application_acks() const;
  void _internal_set_use_application_acks(bool value);
  public:
 
  // optional bool pad_partial_frames = 23 [default = false, (.goby.field) = {
  bool has_pad_partial_frames() const;
  private:
  bool _internal_has_pad_partial_frames() const;
  public:
  void clear_pad_partial_frames();
  bool pad_partial_frames() const;
  void set_pad_partial_frames(bool value);
  private:
  bool _internal_pad_partial_frames() const;
  void _internal_set_pad_partial_frames(bool value);
  public:
 
  // optional bool use_base64_fdp = 40 [default = false];
  bool has_use_base64_fdp() const;
  private:
  bool _internal_has_use_base64_fdp() const;
  public:
  void clear_use_base64_fdp();
  bool use_base64_fdp() const;
  void set_use_base64_fdp(bool value);
  private:
  bool _internal_use_base64_fdp() const;
  void _internal_set_use_base64_fdp(bool value);
  public:
 
  // optional bool query_cfg_on_startup = 22 [default = true];
  bool has_query_cfg_on_startup() const;
  private:
  bool _internal_has_query_cfg_on_startup() const;
  public:
  void clear_query_cfg_on_startup();
  bool query_cfg_on_startup() const;
  void set_query_cfg_on_startup(bool value);
  private:
  bool _internal_query_cfg_on_startup() const;
  void _internal_set_query_cfg_on_startup(bool value);
  public:
 
  // optional int32 keep_alive_seconds = 6 [default = 10];
  bool has_keep_alive_seconds() const;
  private:
  bool _internal_has_keep_alive_seconds() const;
  public:
  void clear_keep_alive_seconds();
  int32_t keep_alive_seconds() const;
  void set_keep_alive_seconds(int32_t value);
  private:
  int32_t _internal_keep_alive_seconds() const;
  void _internal_set_keep_alive_seconds(int32_t value);
  public:
 
  // optional int32 allowed_skew_ms = 7 [default = 1000];
  bool has_allowed_skew_ms() const;
  private:
  bool _internal_has_allowed_skew_ms() const;
  public:
  void clear_allowed_skew_ms();
  int32_t allowed_skew_ms() const;
  void set_allowed_skew_ms(int32_t value);
  private:
  int32_t _internal_allowed_skew_ms() const;
  void _internal_set_allowed_skew_ms(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.Config)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> nvram_cfg_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > additional_application_ack_modem_id_;
    ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl_;
    ::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl_;
    ::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl_;
    ::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep_;
    ::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence_;
    ::goby::acomms::micromodem::protobuf::Config_Revision* revision_;
    uint32_t hydroid_gateway_id_;
    bool reset_nvram_;
    bool use_application_acks_;
    bool pad_partial_frames_;
    bool use_base64_fdp_;
    bool query_cfg_on_startup_;
    int32_t keep_alive_seconds_;
    int32_t allowed_skew_ms_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class RangingReply final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.RangingReply) */ {
 public:
  inline RangingReply() : RangingReply(nullptr) {}
  ~RangingReply() override;
  explicit PROTOBUF_CONSTEXPR RangingReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  RangingReply(const RangingReply& from);
  RangingReply(RangingReply&& from) noexcept
    : RangingReply() {
    *this = ::std::move(from);
  }
 
  inline RangingReply& operator=(const RangingReply& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangingReply& operator=(RangingReply&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RangingReply& default_instance() {
    return *internal_default_instance();
  }
  static inline const RangingReply* internal_default_instance() {
    return reinterpret_cast<const RangingReply*>(
               &_RangingReply_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;
 
  friend void swap(RangingReply& a, RangingReply& b) {
    a.Swap(&b);
  }
  inline void Swap(RangingReply* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangingReply* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  RangingReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RangingReply>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RangingReply& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RangingReply& from) {
    RangingReply::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangingReply* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.RangingReply";
  }
  protected:
  explicit RangingReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef RangingReply_OWTTAmbiguity OWTTAmbiguity;
  static constexpr OWTTAmbiguity OWTT_EXACT =
    RangingReply_OWTTAmbiguity_OWTT_EXACT;
  static constexpr OWTTAmbiguity OWTT_SECOND_AMBIGUOUS =
    RangingReply_OWTTAmbiguity_OWTT_SECOND_AMBIGUOUS;
  static inline bool OWTTAmbiguity_IsValid(int value) {
    return RangingReply_OWTTAmbiguity_IsValid(value);
  }
  static constexpr OWTTAmbiguity OWTTAmbiguity_MIN =
    RangingReply_OWTTAmbiguity_OWTTAmbiguity_MIN;
  static constexpr OWTTAmbiguity OWTTAmbiguity_MAX =
    RangingReply_OWTTAmbiguity_OWTTAmbiguity_MAX;
  static constexpr int OWTTAmbiguity_ARRAYSIZE =
    RangingReply_OWTTAmbiguity_OWTTAmbiguity_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  OWTTAmbiguity_descriptor() {
    return RangingReply_OWTTAmbiguity_descriptor();
  }
  template<typename T>
  static inline const std::string& OWTTAmbiguity_Name(T enum_t_value) {
    static_assert(::std::is_same<T, OWTTAmbiguity>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function OWTTAmbiguity_Name.");
    return RangingReply_OWTTAmbiguity_Name(enum_t_value);
  }
  static inline bool OWTTAmbiguity_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      OWTTAmbiguity* value) {
    return RangingReply_OWTTAmbiguity_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kOneWayTravelTimeFieldNumber = 1,
    kIsOneWaySynchronousFieldNumber = 3,
    kReceiverClkModeFieldNumber = 4,
    kSenderClkModeFieldNumber = 5,
    kAmbiguityFieldNumber = 2,
  };
  // repeated double one_way_travel_time = 1 [(.dccl.field) = {
  int one_way_travel_time_size() const;
  private:
  int _internal_one_way_travel_time_size() const;
  public:
  void clear_one_way_travel_time();
  private:
  double _internal_one_way_travel_time(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_one_way_travel_time() const;
  void _internal_add_one_way_travel_time(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_one_way_travel_time();
  public:
  double one_way_travel_time(int index) const;
  void set_one_way_travel_time(int index, double value);
  void add_one_way_travel_time(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      one_way_travel_time() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_one_way_travel_time();
 
  // optional bool is_one_way_synchronous = 3 [default = false];
  bool has_is_one_way_synchronous() const;
  private:
  bool _internal_has_is_one_way_synchronous() const;
  public:
  void clear_is_one_way_synchronous();
  bool is_one_way_synchronous() const;
  void set_is_one_way_synchronous(bool value);
  private:
  bool _internal_is_one_way_synchronous() const;
  void _internal_set_is_one_way_synchronous(bool value);
  public:
 
  // optional .goby.acomms.micromodem.protobuf.ClockMode receiver_clk_mode = 4 [default = NO_SYNC_TO_PPS_AND_CCCLK_BAD];
  bool has_receiver_clk_mode() const;
  private:
  bool _internal_has_receiver_clk_mode() const;
  public:
  void clear_receiver_clk_mode();
  ::goby::acomms::micromodem::protobuf::ClockMode receiver_clk_mode() const;
  void set_receiver_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
  private:
  ::goby::acomms::micromodem::protobuf::ClockMode _internal_receiver_clk_mode() const;
  void _internal_set_receiver_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
  public:
 
  // optional .goby.acomms.micromodem.protobuf.ClockMode sender_clk_mode = 5 [default = NO_SYNC_TO_PPS_AND_CCCLK_BAD];
  bool has_sender_clk_mode() const;
  private:
  bool _internal_has_sender_clk_mode() const;
  public:
  void clear_sender_clk_mode();
  ::goby::acomms::micromodem::protobuf::ClockMode sender_clk_mode() const;
  void set_sender_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
  private:
  ::goby::acomms::micromodem::protobuf::ClockMode _internal_sender_clk_mode() const;
  void _internal_set_sender_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
  public:
 
  // optional .goby.acomms.micromodem.protobuf.RangingReply.OWTTAmbiguity ambiguity = 2 [default = OWTT_EXACT];
  bool has_ambiguity() const;
  private:
  bool _internal_has_ambiguity() const;
  public:
  void clear_ambiguity();
  ::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity ambiguity() const;
  void set_ambiguity(::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity value);
  private:
  ::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity _internal_ambiguity() const;
  void _internal_set_ambiguity(::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity value);
  public:
 
  enum DCCLParameters { DCCL_ID = 128,  DCCL_MAX_BYTES = 32 };
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type one_way_travel_time_dimension;
  
  typedef boost::units::unit<one_way_travel_time_dimension,boost::units::si::system> one_way_travel_time_unit;
  
  template<typename Quantity >
    void set_one_way_travel_time_with_units(int index, Quantity value_w_units)
    { set_one_way_travel_time(index, boost::units::quantity<one_way_travel_time_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    void add_one_way_travel_time_with_units(Quantity value_w_units)
    { add_one_way_travel_time(boost::units::quantity<one_way_travel_time_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity one_way_travel_time_with_units(int index) const
    { return Quantity(one_way_travel_time(index) * one_way_travel_time_unit()); };
  
  boost::units::quantity< one_way_travel_time_unit,double > one_way_travel_time_with_units(int index) const
    { return one_way_travel_time_with_units<boost::units::quantity< one_way_travel_time_unit,double > >(index); };
  
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.RangingReply)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > one_way_travel_time_;
    bool is_one_way_synchronous_;
    int receiver_clk_mode_;
    int sender_clk_mode_;
    int ambiguity_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class ReceiveStatistics final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.ReceiveStatistics) */ {
 public:
  inline ReceiveStatistics() : ReceiveStatistics(nullptr) {}
  ~ReceiveStatistics() override;
  explicit PROTOBUF_CONSTEXPR ReceiveStatistics(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  ReceiveStatistics(const ReceiveStatistics& from);
  ReceiveStatistics(ReceiveStatistics&& from) noexcept
    : ReceiveStatistics() {
    *this = ::std::move(from);
  }
 
  inline ReceiveStatistics& operator=(const ReceiveStatistics& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReceiveStatistics& operator=(ReceiveStatistics&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReceiveStatistics& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReceiveStatistics* internal_default_instance() {
    return reinterpret_cast<const ReceiveStatistics*>(
               &_ReceiveStatistics_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;
 
  friend void swap(ReceiveStatistics& a, ReceiveStatistics& b) {
    a.Swap(&b);
  }
  inline void Swap(ReceiveStatistics* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ReceiveStatistics* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  ReceiveStatistics* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReceiveStatistics>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReceiveStatistics& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ReceiveStatistics& from) {
    ReceiveStatistics::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReceiveStatistics* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.ReceiveStatistics";
  }
  protected:
  explicit ReceiveStatistics(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kDateFieldNumber = 31,
    kTimeFieldNumber = 2,
    kMfdPeakFieldNumber = 4,
    kMfdPowerFieldNumber = 5,
    kMfdRatioFieldNumber = 6,
    kSplFieldNumber = 7,
    kShfAgnFieldNumber = 8,
    kShfAinpshiftFieldNumber = 9,
    kShfAinshiftFieldNumber = 10,
    kShfMfdshiftFieldNumber = 11,
    kShfP2BshiftFieldNumber = 12,
    kRateFieldNumber = 13,
    kSourceFieldNumber = 14,
    kDestFieldNumber = 15,
    kNumberFramesFieldNumber = 18,
    kNumberBadFramesFieldNumber = 19,
    kSnrRssFieldNumber = 20,
    kSnrInFieldNumber = 21,
    kSnrOutFieldNumber = 22,
    kSnrSymbolsFieldNumber = 23,
    kMseEqualizerFieldNumber = 24,
    kDataQualityFactorFieldNumber = 25,
    kDopplerFieldNumber = 26,
    kStddevNoiseFieldNumber = 27,
    kCarrierFreqFieldNumber = 28,
    kBandwidthFieldNumber = 29,
    kVersionFieldNumber = 30,
    kPcmFieldNumber = 32,
    kModeFieldNumber = 1,
    kClockModeFieldNumber = 3,
    kPskErrorCodeFieldNumber = 16,
    kPacketTypeFieldNumber = 17,
  };
  // optional string date = 31 [(.dccl.field) = {
  bool has_date() const;
  private:
  bool _internal_has_date() const;
  public:
  void clear_date();
  const std::string& date() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_date(ArgT0&& arg0, ArgT... args);
  std::string* mutable_date();
  PROTOBUF_NODISCARD std::string* release_date();
  void set_allocated_date(std::string* date);
  private:
  const std::string& _internal_date() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_date(const std::string& value);
  std::string* _internal_mutable_date();
  public:
 
  // required uint64 time = 2 [(.dccl.field) = {
  bool has_time() const;
  private:
  bool _internal_has_time() const;
  public:
  void clear_time();
  uint64_t time() const;
  void set_time(uint64_t value);
  private:
  uint64_t _internal_time() const;
  void _internal_set_time(uint64_t value);
  public:
 
  // optional int32 mfd_peak = 4 [(.dccl.field) = {
  bool has_mfd_peak() const;
  private:
  bool _internal_has_mfd_peak() const;
  public:
  void clear_mfd_peak();
  int32_t mfd_peak() const;
  void set_mfd_peak(int32_t value);
  private:
  int32_t _internal_mfd_peak() const;
  void _internal_set_mfd_peak(int32_t value);
  public:
 
  // required int32 mfd_power = 5 [(.dccl.field) = {
  bool has_mfd_power() const;
  private:
  bool _internal_has_mfd_power() const;
  public:
  void clear_mfd_power();
  int32_t mfd_power() const;
  void set_mfd_power(int32_t value);
  private:
  int32_t _internal_mfd_power() const;
  void _internal_set_mfd_power(int32_t value);
  public:
 
  // required int32 mfd_ratio = 6 [(.dccl.field) = {
  bool has_mfd_ratio() const;
  private:
  bool _internal_has_mfd_ratio() const;
  public:
  void clear_mfd_ratio();
  int32_t mfd_ratio() const;
  void set_mfd_ratio(int32_t value);
  private:
  int32_t _internal_mfd_ratio() const;
  void _internal_set_mfd_ratio(int32_t value);
  public:
 
  // optional int32 spl = 7 [(.dccl.field) = {
  bool has_spl() const;
  private:
  bool _internal_has_spl() const;
  public:
  void clear_spl();
  int32_t spl() const;
  void set_spl(int32_t value);
  private:
  int32_t _internal_spl() const;
  void _internal_set_spl(int32_t value);
  public:
 
  // optional int32 shf_agn = 8 [(.dccl.field) = {
  bool has_shf_agn() const;
  private:
  bool _internal_has_shf_agn() const;
  public:
  void clear_shf_agn();
  int32_t shf_agn() const;
  void set_shf_agn(int32_t value);
  private:
  int32_t _internal_shf_agn() const;
  void _internal_set_shf_agn(int32_t value);
  public:
 
  // optional int32 shf_ainpshift = 9 [(.dccl.field) = {
  bool has_shf_ainpshift() const;
  private:
  bool _internal_has_shf_ainpshift() const;
  public:
  void clear_shf_ainpshift();
  int32_t shf_ainpshift() const;
  void set_shf_ainpshift(int32_t value);
  private:
  int32_t _internal_shf_ainpshift() const;
  void _internal_set_shf_ainpshift(int32_t value);
  public:
 
  // optional int32 shf_ainshift = 10 [(.dccl.field) = {
  bool has_shf_ainshift() const;
  private:
  bool _internal_has_shf_ainshift() const;
  public:
  void clear_shf_ainshift();
  int32_t shf_ainshift() const;
  void set_shf_ainshift(int32_t value);
  private:
  int32_t _internal_shf_ainshift() const;
  void _internal_set_shf_ainshift(int32_t value);
  public:
 
  // optional int32 shf_mfdshift = 11 [(.dccl.field) = {
  bool has_shf_mfdshift() const;
  private:
  bool _internal_has_shf_mfdshift() const;
  public:
  void clear_shf_mfdshift();
  int32_t shf_mfdshift() const;
  void set_shf_mfdshift(int32_t value);
  private:
  int32_t _internal_shf_mfdshift() const;
  void _internal_set_shf_mfdshift(int32_t value);
  public:
 
  // optional int32 shf_p2bshift = 12 [(.dccl.field) = {
  bool has_shf_p2bshift() const;
  private:
  bool _internal_has_shf_p2bshift() const;
  public:
  void clear_shf_p2bshift();
  int32_t shf_p2bshift() const;
  void set_shf_p2bshift(int32_t value);
  private:
  int32_t _internal_shf_p2bshift() const;
  void _internal_set_shf_p2bshift(int32_t value);
  public:
 
  // required int32 rate = 13 [(.dccl.field) = {
  bool has_rate() const;
  private:
  bool _internal_has_rate() const;
  public:
  void clear_rate();
  int32_t rate() const;
  void set_rate(int32_t value);
  private:
  int32_t _internal_rate() const;
  void _internal_set_rate(int32_t value);
  public:
 
  // required int32 source = 14 [(.dccl.field) = {
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  int32_t source() const;
  void set_source(int32_t value);
  private:
  int32_t _internal_source() const;
  void _internal_set_source(int32_t value);
  public:
 
  // required int32 dest = 15 [(.dccl.field) = {
  bool has_dest() const;
  private:
  bool _internal_has_dest() const;
  public:
  void clear_dest();
  int32_t dest() const;
  void set_dest(int32_t value);
  private:
  int32_t _internal_dest() const;
  void _internal_set_dest(int32_t value);
  public:
 
  // required int32 number_frames = 18 [(.dccl.field) = {
  bool has_number_frames() const;
  private:
  bool _internal_has_number_frames() const;
  public:
  void clear_number_frames();
  int32_t number_frames() const;
  void set_number_frames(int32_t value);
  private:
  int32_t _internal_number_frames() const;
  void _internal_set_number_frames(int32_t value);
  public:
 
  // required int32 number_bad_frames = 19 [(.dccl.field) = {
  bool has_number_bad_frames() const;
  private:
  bool _internal_has_number_bad_frames() const;
  public:
  void clear_number_bad_frames();
  int32_t number_bad_frames() const;
  void set_number_bad_frames(int32_t value);
  private:
  int32_t _internal_number_bad_frames() const;
  void _internal_set_number_bad_frames(int32_t value);
  public:
 
  // required int32 snr_rss = 20 [(.dccl.field) = {
  bool has_snr_rss() const;
  private:
  bool _internal_has_snr_rss() const;
  public:
  void clear_snr_rss();
  int32_t snr_rss() const;
  void set_snr_rss(int32_t value);
  private:
  int32_t _internal_snr_rss() const;
  void _internal_set_snr_rss(int32_t value);
  public:
 
  // required int32 snr_in = 21 [(.dccl.field) = {
  bool has_snr_in() const;
  private:
  bool _internal_has_snr_in() const;
  public:
  void clear_snr_in();
  int32_t snr_in() const;
  void set_snr_in(int32_t value);
  private:
  int32_t _internal_snr_in() const;
  void _internal_set_snr_in(int32_t value);
  public:
 
  // required int32 snr_out = 22 [(.dccl.field) = {
  bool has_snr_out() const;
  private:
  bool _internal_has_snr_out() const;
  public:
  void clear_snr_out();
  int32_t snr_out() const;
  void set_snr_out(int32_t value);
  private:
  int32_t _internal_snr_out() const;
  void _internal_set_snr_out(int32_t value);
  public:
 
  // required int32 snr_symbols = 23 [(.dccl.field) = {
  bool has_snr_symbols() const;
  private:
  bool _internal_has_snr_symbols() const;
  public:
  void clear_snr_symbols();
  int32_t snr_symbols() const;
  void set_snr_symbols(int32_t value);
  private:
  int32_t _internal_snr_symbols() const;
  void _internal_set_snr_symbols(int32_t value);
  public:
 
  // required int32 mse_equalizer = 24 [(.dccl.field) = {
  bool has_mse_equalizer() const;
  private:
  bool _internal_has_mse_equalizer() const;
  public:
  void clear_mse_equalizer();
  int32_t mse_equalizer() const;
  void set_mse_equalizer(int32_t value);
  private:
  int32_t _internal_mse_equalizer() const;
  void _internal_set_mse_equalizer(int32_t value);
  public:
 
  // required int32 data_quality_factor = 25 [(.dccl.field) = {
  bool has_data_quality_factor() const;
  private:
  bool _internal_has_data_quality_factor() const;
  public:
  void clear_data_quality_factor();
  int32_t data_quality_factor() const;
  void set_data_quality_factor(int32_t value);
  private:
  int32_t _internal_data_quality_factor() const;
  void _internal_set_data_quality_factor(int32_t value);
  public:
 
  // required double doppler = 26 [(.dccl.field) = {
  bool has_doppler() const;
  private:
  bool _internal_has_doppler() const;
  public:
  void clear_doppler();
  double doppler() const;
  void set_doppler(double value);
  private:
  double _internal_doppler() const;
  void _internal_set_doppler(double value);
  public:
 
  // required int32 stddev_noise = 27 [(.dccl.field) = {
  bool has_stddev_noise() const;
  private:
  bool _internal_has_stddev_noise() const;
  public:
  void clear_stddev_noise();
  int32_t stddev_noise() const;
  void set_stddev_noise(int32_t value);
  private:
  int32_t _internal_stddev_noise() const;
  void _internal_set_stddev_noise(int32_t value);
  public:
 
  // required int32 carrier_freq = 28 [(.dccl.field) = {
  bool has_carrier_freq() const;
  private:
  bool _internal_has_carrier_freq() const;
  public:
  void clear_carrier_freq();
  int32_t carrier_freq() const;
  void set_carrier_freq(int32_t value);
  private:
  int32_t _internal_carrier_freq() const;
  void _internal_set_carrier_freq(int32_t value);
  public:
 
  // required int32 bandwidth = 29 [(.dccl.field) = {
  bool has_bandwidth() const;
  private:
  bool _internal_has_bandwidth() const;
  public:
  void clear_bandwidth();
  int32_t bandwidth() const;
  void set_bandwidth(int32_t value);
  private:
  int32_t _internal_bandwidth() const;
  void _internal_set_bandwidth(int32_t value);
  public:
 
  // optional int32 version = 30 [default = 0, (.dccl.field) = {
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  int32_t version() const;
  void set_version(int32_t value);
  private:
  int32_t _internal_version() const;
  void _internal_set_version(int32_t value);
  public:
 
  // optional int32 pcm = 32 [(.dccl.field) = {
  bool has_pcm() const;
  private:
  bool _internal_has_pcm() const;
  public:
  void clear_pcm();
  int32_t pcm() const;
  void set_pcm(int32_t value);
  private:
  int32_t _internal_pcm() const;
  void _internal_set_pcm(int32_t value);
  public:
 
  // required .goby.acomms.micromodem.protobuf.ReceiveMode mode = 1;
  bool has_mode() const;
  private:
  bool _internal_has_mode() const;
  public:
  void clear_mode();
  ::goby::acomms::micromodem::protobuf::ReceiveMode mode() const;
  void set_mode(::goby::acomms::micromodem::protobuf::ReceiveMode value);
  private:
  ::goby::acomms::micromodem::protobuf::ReceiveMode _internal_mode() const;
  void _internal_set_mode(::goby::acomms::micromodem::protobuf::ReceiveMode value);
  public:
 
  // required .goby.acomms.micromodem.protobuf.ClockMode clock_mode = 3;
  bool has_clock_mode() const;
  private:
  bool _internal_has_clock_mode() const;
  public:
  void clear_clock_mode();
  ::goby::acomms::micromodem::protobuf::ClockMode clock_mode() const;
  void set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
  private:
  ::goby::acomms::micromodem::protobuf::ClockMode _internal_clock_mode() const;
  void _internal_set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
  public:
 
  // required .goby.acomms.micromodem.protobuf.PSKErrorCode psk_error_code = 16;
  bool has_psk_error_code() const;
  private:
  bool _internal_has_psk_error_code() const;
  public:
  void clear_psk_error_code();
  ::goby::acomms::micromodem::protobuf::PSKErrorCode psk_error_code() const;
  void set_psk_error_code(::goby::acomms::micromodem::protobuf::PSKErrorCode value);
  private:
  ::goby::acomms::micromodem::protobuf::PSKErrorCode _internal_psk_error_code() const;
  void _internal_set_psk_error_code(::goby::acomms::micromodem::protobuf::PSKErrorCode value);
  public:
 
  // required .goby.acomms.micromodem.protobuf.PacketType packet_type = 17;
  bool has_packet_type() const;
  private:
  bool _internal_has_packet_type() const;
  public:
  void clear_packet_type();
  ::goby::acomms::micromodem::protobuf::PacketType packet_type() const;
  void set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value);
  private:
  ::goby::acomms::micromodem::protobuf::PacketType _internal_packet_type() const;
  void _internal_set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value);
  public:
 
  enum DCCLParameters { DCCL_ID = 129,  DCCL_MAX_BYTES = 32 };
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type time_dimension;
  
  typedef boost::units::make_scaled_unit<boost::units::unit<time_dimension,boost::units::si::system> , boost::units::scale<10, boost::units::static_rational<-6> > >::type time_unit;
  
  template<typename Quantity >
    void set_time_with_units(Quantity value_w_units)
    { set_time(boost::units::quantity<time_unit,google::protobuf::uint64 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity time_with_units() const
    { return Quantity(time() * time_unit()); };
  
  boost::units::quantity< time_unit,google::protobuf::uint64 > time_with_units() const
    { return time_with_units<boost::units::quantity< time_unit,google::protobuf::uint64 > >(); };
  
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.ReceiveStatistics)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr date_;
    uint64_t time_;
    int32_t mfd_peak_;
    int32_t mfd_power_;
    int32_t mfd_ratio_;
    int32_t spl_;
    int32_t shf_agn_;
    int32_t shf_ainpshift_;
    int32_t shf_ainshift_;
    int32_t shf_mfdshift_;
    int32_t shf_p2bshift_;
    int32_t rate_;
    int32_t source_;
    int32_t dest_;
    int32_t number_frames_;
    int32_t number_bad_frames_;
    int32_t snr_rss_;
    int32_t snr_in_;
    int32_t snr_out_;
    int32_t snr_symbols_;
    int32_t mse_equalizer_;
    int32_t data_quality_factor_;
    double doppler_;
    int32_t stddev_noise_;
    int32_t carrier_freq_;
    int32_t bandwidth_;
    int32_t version_;
    int32_t pcm_;
    int mode_;
    int clock_mode_;
    int psk_error_code_;
    int packet_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class TransmitStatistics final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.TransmitStatistics) */ {
 public:
  inline TransmitStatistics() : TransmitStatistics(nullptr) {}
  ~TransmitStatistics() override;
  explicit PROTOBUF_CONSTEXPR TransmitStatistics(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  TransmitStatistics(const TransmitStatistics& from);
  TransmitStatistics(TransmitStatistics&& from) noexcept
    : TransmitStatistics() {
    *this = ::std::move(from);
  }
 
  inline TransmitStatistics& operator=(const TransmitStatistics& from) {
    CopyFrom(from);
    return *this;
  }
  inline TransmitStatistics& operator=(TransmitStatistics&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TransmitStatistics& default_instance() {
    return *internal_default_instance();
  }
  static inline const TransmitStatistics* internal_default_instance() {
    return reinterpret_cast<const TransmitStatistics*>(
               &_TransmitStatistics_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;
 
  friend void swap(TransmitStatistics& a, TransmitStatistics& b) {
    a.Swap(&b);
  }
  inline void Swap(TransmitStatistics* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TransmitStatistics* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  TransmitStatistics* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TransmitStatistics>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TransmitStatistics& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TransmitStatistics& from) {
    TransmitStatistics::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TransmitStatistics* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.TransmitStatistics";
  }
  protected:
  explicit TransmitStatistics(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kDateFieldNumber = 1,
    kTimeFieldNumber = 2,
    kProbeLengthFieldNumber = 5,
    kBandwidthFieldNumber = 6,
    kCarrierFreqFieldNumber = 7,
    kRateFieldNumber = 8,
    kSourceFieldNumber = 9,
    kDestFieldNumber = 10,
    kAckRequestedFieldNumber = 11,
    kNumberFramesExpectedFieldNumber = 12,
    kNumberFramesSentFieldNumber = 13,
    kNumberBytesFieldNumber = 15,
    kVersionFieldNumber = 100,
    kPacketTypeFieldNumber = 14,
    kClockModeFieldNumber = 3,
    kModeFieldNumber = 4,
  };
  // optional string date = 1;
  bool has_date() const;
  private:
  bool _internal_has_date() const;
  public:
  void clear_date();
  const std::string& date() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_date(ArgT0&& arg0, ArgT... args);
  std::string* mutable_date();
  PROTOBUF_NODISCARD std::string* release_date();
  void set_allocated_date(std::string* date);
  private:
  const std::string& _internal_date() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_date(const std::string& value);
  std::string* _internal_mutable_date();
  public:
 
  // optional string time = 2;
  bool has_time() const;
  private:
  bool _internal_has_time() const;
  public:
  void clear_time();
  const std::string& time() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_time(ArgT0&& arg0, ArgT... args);
  std::string* mutable_time();
  PROTOBUF_NODISCARD std::string* release_time();
  void set_allocated_time(std::string* time);
  private:
  const std::string& _internal_time() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_time(const std::string& value);
  std::string* _internal_mutable_time();
  public:
 
  // optional int32 probe_length = 5;
  bool has_probe_length() const;
  private:
  bool _internal_has_probe_length() const;
  public:
  void clear_probe_length();
  int32_t probe_length() const;
  void set_probe_length(int32_t value);
  private:
  int32_t _internal_probe_length() const;
  void _internal_set_probe_length(int32_t value);
  public:
 
  // optional int32 bandwidth = 6;
  bool has_bandwidth() const;
  private:
  bool _internal_has_bandwidth() const;
  public:
  void clear_bandwidth();
  int32_t bandwidth() const;
  void set_bandwidth(int32_t value);
  private:
  int32_t _internal_bandwidth() const;
  void _internal_set_bandwidth(int32_t value);
  public:
 
  // optional int32 carrier_freq = 7;
  bool has_carrier_freq() const;
  private:
  bool _internal_has_carrier_freq() const;
  public:
  void clear_carrier_freq();
  int32_t carrier_freq() const;
  void set_carrier_freq(int32_t value);
  private:
  int32_t _internal_carrier_freq() const;
  void _internal_set_carrier_freq(int32_t value);
  public:
 
  // optional int32 rate = 8;
  bool has_rate() const;
  private:
  bool _internal_has_rate() const;
  public:
  void clear_rate();
  int32_t rate() const;
  void set_rate(int32_t value);
  private:
  int32_t _internal_rate() const;
  void _internal_set_rate(int32_t value);
  public:
 
  // optional int32 source = 9;
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  int32_t source() const;
  void set_source(int32_t value);
  private:
  int32_t _internal_source() const;
  void _internal_set_source(int32_t value);
  public:
 
  // optional int32 dest = 10;
  bool has_dest() const;
  private:
  bool _internal_has_dest() const;
  public:
  void clear_dest();
  int32_t dest() const;
  void set_dest(int32_t value);
  private:
  int32_t _internal_dest() const;
  void _internal_set_dest(int32_t value);
  public:
 
  // optional bool ack_requested = 11;
  bool has_ack_requested() const;
  private:
  bool _internal_has_ack_requested() const;
  public:
  void clear_ack_requested();
  bool ack_requested() const;
  void set_ack_requested(bool value);
  private:
  bool _internal_ack_requested() const;
  void _internal_set_ack_requested(bool value);
  public:
 
  // optional int32 number_frames_expected = 12;
  bool has_number_frames_expected() const;
  private:
  bool _internal_has_number_frames_expected() const;
  public:
  void clear_number_frames_expected();
  int32_t number_frames_expected() const;
  void set_number_frames_expected(int32_t value);
  private:
  int32_t _internal_number_frames_expected() const;
  void _internal_set_number_frames_expected(int32_t value);
  public:
 
  // optional int32 number_frames_sent = 13;
  bool has_number_frames_sent() const;
  private:
  bool _internal_has_number_frames_sent() const;
  public:
  void clear_number_frames_sent();
  int32_t number_frames_sent() const;
  void set_number_frames_sent(int32_t value);
  private:
  int32_t _internal_number_frames_sent() const;
  void _internal_set_number_frames_sent(int32_t value);
  public:
 
  // optional int32 number_bytes = 15;
  bool has_number_bytes() const;
  private:
  bool _internal_has_number_bytes() const;
  public:
  void clear_number_bytes();
  int32_t number_bytes() const;
  void set_number_bytes(int32_t value);
  private:
  int32_t _internal_number_bytes() const;
  void _internal_set_number_bytes(int32_t value);
  public:
 
  // optional int32 version = 100 [default = 0];
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  int32_t version() const;
  void set_version(int32_t value);
  private:
  int32_t _internal_version() const;
  void _internal_set_version(int32_t value);
  public:
 
  // optional .goby.acomms.micromodem.protobuf.PacketType packet_type = 14;
  bool has_packet_type() const;
  private:
  bool _internal_has_packet_type() const;
  public:
  void clear_packet_type();
  ::goby::acomms::micromodem::protobuf::PacketType packet_type() const;
  void set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value);
  private:
  ::goby::acomms::micromodem::protobuf::PacketType _internal_packet_type() const;
  void _internal_set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value);
  public:
 
  // optional .goby.acomms.micromodem.protobuf.ClockMode clock_mode = 3;
  bool has_clock_mode() const;
  private:
  bool _internal_has_clock_mode() const;
  public:
  void clear_clock_mode();
  ::goby::acomms::micromodem::protobuf::ClockMode clock_mode() const;
  void set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
  private:
  ::goby::acomms::micromodem::protobuf::ClockMode _internal_clock_mode() const;
  void _internal_set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
  public:
 
  // optional .goby.acomms.micromodem.protobuf.TransmitMode mode = 4;
  bool has_mode() const;
  private:
  bool _internal_has_mode() const;
  public:
  void clear_mode();
  ::goby::acomms::micromodem::protobuf::TransmitMode mode() const;
  void set_mode(::goby::acomms::micromodem::protobuf::TransmitMode value);
  private:
  ::goby::acomms::micromodem::protobuf::TransmitMode _internal_mode() const;
  void _internal_set_mode(::goby::acomms::micromodem::protobuf::TransmitMode value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.TransmitStatistics)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr date_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr time_;
    int32_t probe_length_;
    int32_t bandwidth_;
    int32_t carrier_freq_;
    int32_t rate_;
    int32_t source_;
    int32_t dest_;
    bool ack_requested_;
    int32_t number_frames_expected_;
    int32_t number_frames_sent_;
    int32_t number_bytes_;
    int32_t version_;
    int packet_type_;
    int clock_mode_;
    int mode_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class HardwareControl final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.HardwareControl) */ {
 public:
  inline HardwareControl() : HardwareControl(nullptr) {}
  ~HardwareControl() override;
  explicit PROTOBUF_CONSTEXPR HardwareControl(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  HardwareControl(const HardwareControl& from);
  HardwareControl(HardwareControl&& from) noexcept
    : HardwareControl() {
    *this = ::std::move(from);
  }
 
  inline HardwareControl& operator=(const HardwareControl& from) {
    CopyFrom(from);
    return *this;
  }
  inline HardwareControl& operator=(HardwareControl&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HardwareControl& default_instance() {
    return *internal_default_instance();
  }
  static inline const HardwareControl* internal_default_instance() {
    return reinterpret_cast<const HardwareControl*>(
               &_HardwareControl_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;
 
  friend void swap(HardwareControl& a, HardwareControl& b) {
    a.Swap(&b);
  }
  inline void Swap(HardwareControl* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HardwareControl* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  HardwareControl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HardwareControl>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HardwareControl& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HardwareControl& from) {
    HardwareControl::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HardwareControl* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.HardwareControl";
  }
  protected:
  explicit HardwareControl(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kModeFieldNumber = 2,
    kArgFieldNumber = 3,
    kLineFieldNumber = 1,
  };
  // required .goby.acomms.micromodem.protobuf.HardwareControlMode mode = 2;
  bool has_mode() const;
  private:
  bool _internal_has_mode() const;
  public:
  void clear_mode();
  ::goby::acomms::micromodem::protobuf::HardwareControlMode mode() const;
  void set_mode(::goby::acomms::micromodem::protobuf::HardwareControlMode value);
  private:
  ::goby::acomms::micromodem::protobuf::HardwareControlMode _internal_mode() const;
  void _internal_set_mode(::goby::acomms::micromodem::protobuf::HardwareControlMode value);
  public:
 
  // optional .goby.acomms.micromodem.protobuf.HardwareControlArgument arg = 3 [default = MODE0_ARG];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  ::goby::acomms::micromodem::protobuf::HardwareControlArgument arg() const;
  void set_arg(::goby::acomms::micromodem::protobuf::HardwareControlArgument value);
  private:
  ::goby::acomms::micromodem::protobuf::HardwareControlArgument _internal_arg() const;
  void _internal_set_arg(::goby::acomms::micromodem::protobuf::HardwareControlArgument value);
  public:
 
  // required .goby.acomms.micromodem.protobuf.HardwareLine line = 1;
  bool has_line() const;
  private:
  bool _internal_has_line() const;
  public:
  void clear_line();
  ::goby::acomms::micromodem::protobuf::HardwareLine line() const;
  void set_line(::goby::acomms::micromodem::protobuf::HardwareLine value);
  private:
  ::goby::acomms::micromodem::protobuf::HardwareLine _internal_line() const;
  void _internal_set_line(::goby::acomms::micromodem::protobuf::HardwareLine value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.HardwareControl)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int mode_;
    int arg_;
    int line_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class HardwareControlCommand final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.HardwareControlCommand) */ {
 public:
  inline HardwareControlCommand() : HardwareControlCommand(nullptr) {}
  ~HardwareControlCommand() override;
  explicit PROTOBUF_CONSTEXPR HardwareControlCommand(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  HardwareControlCommand(const HardwareControlCommand& from);
  HardwareControlCommand(HardwareControlCommand&& from) noexcept
    : HardwareControlCommand() {
    *this = ::std::move(from);
  }
 
  inline HardwareControlCommand& operator=(const HardwareControlCommand& from) {
    CopyFrom(from);
    return *this;
  }
  inline HardwareControlCommand& operator=(HardwareControlCommand&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HardwareControlCommand& default_instance() {
    return *internal_default_instance();
  }
  static inline const HardwareControlCommand* internal_default_instance() {
    return reinterpret_cast<const HardwareControlCommand*>(
               &_HardwareControlCommand_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;
 
  friend void swap(HardwareControlCommand& a, HardwareControlCommand& b) {
    a.Swap(&b);
  }
  inline void Swap(HardwareControlCommand* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HardwareControlCommand* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  HardwareControlCommand* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HardwareControlCommand>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HardwareControlCommand& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HardwareControlCommand& from) {
    HardwareControlCommand::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HardwareControlCommand* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.HardwareControlCommand";
  }
  protected:
  explicit HardwareControlCommand(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kControlFieldNumber = 5,
    kCommandSrcFieldNumber = 1,
    kCommandDestFieldNumber = 2,
    kTimeFieldNumber = 3,
    kHwCtlDestFieldNumber = 4,
  };
  // optional .goby.acomms.micromodem.protobuf.HardwareControl control = 5;
  bool has_control() const;
  private:
  bool _internal_has_control() const;
  public:
  void clear_control();
  const ::goby::acomms::micromodem::protobuf::HardwareControl& control() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::HardwareControl* release_control();
  ::goby::acomms::micromodem::protobuf::HardwareControl* mutable_control();
  void set_allocated_control(::goby::acomms::micromodem::protobuf::HardwareControl* control);
  private:
  const ::goby::acomms::micromodem::protobuf::HardwareControl& _internal_control() const;
  ::goby::acomms::micromodem::protobuf::HardwareControl* _internal_mutable_control();
  public:
  void unsafe_arena_set_allocated_control(
      ::goby::acomms::micromodem::protobuf::HardwareControl* control);
  ::goby::acomms::micromodem::protobuf::HardwareControl* unsafe_arena_release_control();
 
  // required int32 command_src = 1 [(.dccl.field) = {
  bool has_command_src() const;
  private:
  bool _internal_has_command_src() const;
  public:
  void clear_command_src();
  int32_t command_src() const;
  void set_command_src(int32_t value);
  private:
  int32_t _internal_command_src() const;
  void _internal_set_command_src(int32_t value);
  public:
 
  // required int32 command_dest = 2 [(.dccl.field) = {
  bool has_command_dest() const;
  private:
  bool _internal_has_command_dest() const;
  public:
  void clear_command_dest();
  int32_t command_dest() const;
  void set_command_dest(int32_t value);
  private:
  int32_t _internal_command_dest() const;
  void _internal_set_command_dest(int32_t value);
  public:
 
  // optional uint64 time = 3 [(.dccl.field) = {
  bool has_time() const;
  private:
  bool _internal_has_time() const;
  public:
  void clear_time();
  uint64_t time() const;
  void set_time(uint64_t value);
  private:
  uint64_t _internal_time() const;
  void _internal_set_time(uint64_t value);
  public:
 
  // optional int32 hw_ctl_dest = 4 [(.dccl.field) = {
  bool has_hw_ctl_dest() const;
  private:
  bool _internal_has_hw_ctl_dest() const;
  public:
  void clear_hw_ctl_dest();
  int32_t hw_ctl_dest() const;
  void set_hw_ctl_dest(int32_t value);
  private:
  int32_t _internal_hw_ctl_dest() const;
  void _internal_set_hw_ctl_dest(int32_t value);
  public:
 
  enum DCCLParameters { DCCL_ID = 515,  DCCL_MAX_BYTES = 32 };
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.HardwareControlCommand)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::goby::acomms::micromodem::protobuf::HardwareControl* control_;
    int32_t command_src_;
    int32_t command_dest_;
    uint64_t time_;
    int32_t hw_ctl_dest_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class Transmission final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.Transmission) */ {
 public:
  inline Transmission() : Transmission(nullptr) {}
  ~Transmission() override;
  explicit PROTOBUF_CONSTEXPR Transmission(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Transmission(const Transmission& from);
  Transmission(Transmission&& from) noexcept
    : Transmission() {
    *this = ::std::move(from);
  }
 
  inline Transmission& operator=(const Transmission& from) {
    CopyFrom(from);
    return *this;
  }
  inline Transmission& operator=(Transmission&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Transmission& default_instance() {
    return *internal_default_instance();
  }
  static inline const Transmission* internal_default_instance() {
    return reinterpret_cast<const Transmission*>(
               &_Transmission_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;
 
  friend void swap(Transmission& a, Transmission& b) {
    a.Swap(&b);
  }
  inline void Swap(Transmission* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Transmission* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Transmission* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Transmission>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Transmission& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Transmission& from) {
    Transmission::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Transmission* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.Transmission";
  }
  protected:
  explicit Transmission(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kReceiveStatFieldNumber = 5,
    kTransmitStatFieldNumber = 6,
    kFrameWithBadCrcFieldNumber = 7,
    kNarrowbandLblFieldNumber = 2,
    kRemusLblFieldNumber = 3,
    kRangingReplyFieldNumber = 4,
    kHwCtlFieldNumber = 8,
    kGenericLblFieldNumber = 9,
    kFmSweepFieldNumber = 10,
    kMSequenceFieldNumber = 11,
    kTypeFieldNumber = 1,
  };
  // repeated .goby.acomms.micromodem.protobuf.ReceiveStatistics receive_stat = 5 [(.goby.field) = {
  int receive_stat_size() const;
  private:
  int _internal_receive_stat_size() const;
  public:
  void clear_receive_stat();
  ::goby::acomms::micromodem::protobuf::ReceiveStatistics* mutable_receive_stat(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::ReceiveStatistics >*
      mutable_receive_stat();
  private:
  const ::goby::acomms::micromodem::protobuf::ReceiveStatistics& _internal_receive_stat(int index) const;
  ::goby::acomms::micromodem::protobuf::ReceiveStatistics* _internal_add_receive_stat();
  public:
  const ::goby::acomms::micromodem::protobuf::ReceiveStatistics& receive_stat(int index) const;
  ::goby::acomms::micromodem::protobuf::ReceiveStatistics* add_receive_stat();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::ReceiveStatistics >&
      receive_stat() const;
 
  // repeated .goby.acomms.micromodem.protobuf.TransmitStatistics transmit_stat = 6 [(.goby.field) = {
  int transmit_stat_size() const;
  private:
  int _internal_transmit_stat_size() const;
  public:
  void clear_transmit_stat();
  ::goby::acomms::micromodem::protobuf::TransmitStatistics* mutable_transmit_stat(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::TransmitStatistics >*
      mutable_transmit_stat();
  private:
  const ::goby::acomms::micromodem::protobuf::TransmitStatistics& _internal_transmit_stat(int index) const;
  ::goby::acomms::micromodem::protobuf::TransmitStatistics* _internal_add_transmit_stat();
  public:
  const ::goby::acomms::micromodem::protobuf::TransmitStatistics& transmit_stat(int index) const;
  ::goby::acomms::micromodem::protobuf::TransmitStatistics* add_transmit_stat();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::TransmitStatistics >&
      transmit_stat() const;
 
  // repeated int32 frame_with_bad_crc = 7 [(.goby.field) = {
  int frame_with_bad_crc_size() const;
  private:
  int _internal_frame_with_bad_crc_size() const;
  public:
  void clear_frame_with_bad_crc();
  private:
  int32_t _internal_frame_with_bad_crc(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_frame_with_bad_crc() const;
  void _internal_add_frame_with_bad_crc(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_frame_with_bad_crc();
  public:
  int32_t frame_with_bad_crc(int index) const;
  void set_frame_with_bad_crc(int index, int32_t value);
  void add_frame_with_bad_crc(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      frame_with_bad_crc() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_frame_with_bad_crc();
 
  // optional .goby.acomms.micromodem.protobuf.NarrowBandLBLParams narrowband_lbl = 2 [(.dccl.field) = {
  bool has_narrowband_lbl() const;
  private:
  bool _internal_has_narrowband_lbl() const;
  public:
  void clear_narrowband_lbl();
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& narrowband_lbl() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* release_narrowband_lbl();
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* mutable_narrowband_lbl();
  void set_allocated_narrowband_lbl(::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl);
  private:
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& _internal_narrowband_lbl() const;
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* _internal_mutable_narrowband_lbl();
  public:
  void unsafe_arena_set_allocated_narrowband_lbl(
      ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl);
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* unsafe_arena_release_narrowband_lbl();
 
  // optional .goby.acomms.micromodem.protobuf.REMUSLBLParams remus_lbl = 3 [(.dccl.field) = {
  bool has_remus_lbl() const;
  private:
  bool _internal_has_remus_lbl() const;
  public:
  void clear_remus_lbl();
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& remus_lbl() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::REMUSLBLParams* release_remus_lbl();
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* mutable_remus_lbl();
  void set_allocated_remus_lbl(::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl);
  private:
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& _internal_remus_lbl() const;
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* _internal_mutable_remus_lbl();
  public:
  void unsafe_arena_set_allocated_remus_lbl(
      ::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl);
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* unsafe_arena_release_remus_lbl();
 
  // optional .goby.acomms.micromodem.protobuf.RangingReply ranging_reply = 4 [(.goby.field) = {
  bool has_ranging_reply() const;
  private:
  bool _internal_has_ranging_reply() const;
  public:
  void clear_ranging_reply();
  const ::goby::acomms::micromodem::protobuf::RangingReply& ranging_reply() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::RangingReply* release_ranging_reply();
  ::goby::acomms::micromodem::protobuf::RangingReply* mutable_ranging_reply();
  void set_allocated_ranging_reply(::goby::acomms::micromodem::protobuf::RangingReply* ranging_reply);
  private:
  const ::goby::acomms::micromodem::protobuf::RangingReply& _internal_ranging_reply() const;
  ::goby::acomms::micromodem::protobuf::RangingReply* _internal_mutable_ranging_reply();
  public:
  void unsafe_arena_set_allocated_ranging_reply(
      ::goby::acomms::micromodem::protobuf::RangingReply* ranging_reply);
  ::goby::acomms::micromodem::protobuf::RangingReply* unsafe_arena_release_ranging_reply();
 
  // optional .goby.acomms.micromodem.protobuf.HardwareControl hw_ctl = 8 [(.dccl.field) = {
  bool has_hw_ctl() const;
  private:
  bool _internal_has_hw_ctl() const;
  public:
  void clear_hw_ctl();
  const ::goby::acomms::micromodem::protobuf::HardwareControl& hw_ctl() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::HardwareControl* release_hw_ctl();
  ::goby::acomms::micromodem::protobuf::HardwareControl* mutable_hw_ctl();
  void set_allocated_hw_ctl(::goby::acomms::micromodem::protobuf::HardwareControl* hw_ctl);
  private:
  const ::goby::acomms::micromodem::protobuf::HardwareControl& _internal_hw_ctl() const;
  ::goby::acomms::micromodem::protobuf::HardwareControl* _internal_mutable_hw_ctl();
  public:
  void unsafe_arena_set_allocated_hw_ctl(
      ::goby::acomms::micromodem::protobuf::HardwareControl* hw_ctl);
  ::goby::acomms::micromodem::protobuf::HardwareControl* unsafe_arena_release_hw_ctl();
 
  // optional .goby.acomms.micromodem.protobuf.GenericLBLParams generic_lbl = 9 [(.dccl.field) = {
  bool has_generic_lbl() const;
  private:
  bool _internal_has_generic_lbl() const;
  public:
  void clear_generic_lbl();
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams& generic_lbl() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::GenericLBLParams* release_generic_lbl();
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* mutable_generic_lbl();
  void set_allocated_generic_lbl(::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl);
  private:
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams& _internal_generic_lbl() const;
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* _internal_mutable_generic_lbl();
  public:
  void unsafe_arena_set_allocated_generic_lbl(
      ::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl);
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* unsafe_arena_release_generic_lbl();
 
  // optional .goby.acomms.micromodem.protobuf.FMSweepParams fm_sweep = 10 [(.dccl.field) = {
  bool has_fm_sweep() const;
  private:
  bool _internal_has_fm_sweep() const;
  public:
  void clear_fm_sweep();
  const ::goby::acomms::micromodem::protobuf::FMSweepParams& fm_sweep() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::FMSweepParams* release_fm_sweep();
  ::goby::acomms::micromodem::protobuf::FMSweepParams* mutable_fm_sweep();
  void set_allocated_fm_sweep(::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep);
  private:
  const ::goby::acomms::micromodem::protobuf::FMSweepParams& _internal_fm_sweep() const;
  ::goby::acomms::micromodem::protobuf::FMSweepParams* _internal_mutable_fm_sweep();
  public:
  void unsafe_arena_set_allocated_fm_sweep(
      ::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep);
  ::goby::acomms::micromodem::protobuf::FMSweepParams* unsafe_arena_release_fm_sweep();
 
  // optional .goby.acomms.micromodem.protobuf.MSequenceParams m_sequence = 11 [(.dccl.field) = {
  bool has_m_sequence() const;
  private:
  bool _internal_has_m_sequence() const;
  public:
  void clear_m_sequence();
  const ::goby::acomms::micromodem::protobuf::MSequenceParams& m_sequence() const;
  PROTOBUF_NODISCARD ::goby::acomms::micromodem::protobuf::MSequenceParams* release_m_sequence();
  ::goby::acomms::micromodem::protobuf::MSequenceParams* mutable_m_sequence();
  void set_allocated_m_sequence(::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence);
  private:
  const ::goby::acomms::micromodem::protobuf::MSequenceParams& _internal_m_sequence() const;
  ::goby::acomms::micromodem::protobuf::MSequenceParams* _internal_mutable_m_sequence();
  public:
  void unsafe_arena_set_allocated_m_sequence(
      ::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence);
  ::goby::acomms::micromodem::protobuf::MSequenceParams* unsafe_arena_release_m_sequence();
 
  // optional .goby.acomms.micromodem.protobuf.TransmissionType type = 1 [default = BASE_TYPE, (.goby.field) = {
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::goby::acomms::micromodem::protobuf::TransmissionType type() const;
  void set_type(::goby::acomms::micromodem::protobuf::TransmissionType value);
  private:
  ::goby::acomms::micromodem::protobuf::TransmissionType _internal_type() const;
  void _internal_set_type(::goby::acomms::micromodem::protobuf::TransmissionType value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.Transmission)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::ReceiveStatistics > receive_stat_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::TransmitStatistics > transmit_stat_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > frame_with_bad_crc_;
    ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl_;
    ::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl_;
    ::goby::acomms::micromodem::protobuf::RangingReply* ranging_reply_;
    ::goby::acomms::micromodem::protobuf::HardwareControl* hw_ctl_;
    ::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl_;
    ::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep_;
    ::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class MMApplicationAck_AckPart final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart) */ {
 public:
  inline MMApplicationAck_AckPart() : MMApplicationAck_AckPart(nullptr) {}
  ~MMApplicationAck_AckPart() override;
  explicit PROTOBUF_CONSTEXPR MMApplicationAck_AckPart(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MMApplicationAck_AckPart(const MMApplicationAck_AckPart& from);
  MMApplicationAck_AckPart(MMApplicationAck_AckPart&& from) noexcept
    : MMApplicationAck_AckPart() {
    *this = ::std::move(from);
  }
 
  inline MMApplicationAck_AckPart& operator=(const MMApplicationAck_AckPart& from) {
    CopyFrom(from);
    return *this;
  }
  inline MMApplicationAck_AckPart& operator=(MMApplicationAck_AckPart&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MMApplicationAck_AckPart& default_instance() {
    return *internal_default_instance();
  }
  static inline const MMApplicationAck_AckPart* internal_default_instance() {
    return reinterpret_cast<const MMApplicationAck_AckPart*>(
               &_MMApplicationAck_AckPart_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;
 
  friend void swap(MMApplicationAck_AckPart& a, MMApplicationAck_AckPart& b) {
    a.Swap(&b);
  }
  inline void Swap(MMApplicationAck_AckPart* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MMApplicationAck_AckPart* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MMApplicationAck_AckPart* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MMApplicationAck_AckPart>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MMApplicationAck_AckPart& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MMApplicationAck_AckPart& from) {
    MMApplicationAck_AckPart::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MMApplicationAck_AckPart* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart";
  }
  protected:
  explicit MMApplicationAck_AckPart(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kAckDestFieldNumber = 1,
    kAckedFramesFieldNumber = 2,
  };
  // required int32 ack_dest = 1 [(.dccl.field) = {
  bool has_ack_dest() const;
  private:
  bool _internal_has_ack_dest() const;
  public:
  void clear_ack_dest();
  int32_t ack_dest() const;
  void set_ack_dest(int32_t value);
  private:
  int32_t _internal_ack_dest() const;
  void _internal_set_ack_dest(int32_t value);
  public:
 
  // required uint32 acked_frames = 2 [(.dccl.field) = {
  bool has_acked_frames() const;
  private:
  bool _internal_has_acked_frames() const;
  public:
  void clear_acked_frames();
  uint32_t acked_frames() const;
  void set_acked_frames(uint32_t value);
  private:
  uint32_t _internal_acked_frames() const;
  void _internal_set_acked_frames(uint32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t ack_dest_;
    uint32_t acked_frames_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class MMApplicationAck final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.MMApplicationAck) */ {
 public:
  inline MMApplicationAck() : MMApplicationAck(nullptr) {}
  ~MMApplicationAck() override;
  explicit PROTOBUF_CONSTEXPR MMApplicationAck(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MMApplicationAck(const MMApplicationAck& from);
  MMApplicationAck(MMApplicationAck&& from) noexcept
    : MMApplicationAck() {
    *this = ::std::move(from);
  }
 
  inline MMApplicationAck& operator=(const MMApplicationAck& from) {
    CopyFrom(from);
    return *this;
  }
  inline MMApplicationAck& operator=(MMApplicationAck&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MMApplicationAck& default_instance() {
    return *internal_default_instance();
  }
  static inline const MMApplicationAck* internal_default_instance() {
    return reinterpret_cast<const MMApplicationAck*>(
               &_MMApplicationAck_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;
 
  friend void swap(MMApplicationAck& a, MMApplicationAck& b) {
    a.Swap(&b);
  }
  inline void Swap(MMApplicationAck* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MMApplicationAck* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MMApplicationAck* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MMApplicationAck>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MMApplicationAck& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MMApplicationAck& from) {
    MMApplicationAck::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MMApplicationAck* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.micromodem.protobuf.MMApplicationAck";
  }
  protected:
  explicit MMApplicationAck(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef MMApplicationAck_AckPart AckPart;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kPartFieldNumber = 1,
    kAckRequestedFieldNumber = 3,
    kFrameStartFieldNumber = 4,
  };
  // repeated .goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart part = 1 [(.dccl.field) = {
  int part_size() const;
  private:
  int _internal_part_size() const;
  public:
  void clear_part();
  ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart* mutable_part(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart >*
      mutable_part();
  private:
  const ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart& _internal_part(int index) const;
  ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart* _internal_add_part();
  public:
  const ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart& part(int index) const;
  ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart* add_part();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart >&
      part() const;
 
  // required bool ack_requested = 3;
  bool has_ack_requested() const;
  private:
  bool _internal_has_ack_requested() const;
  public:
  void clear_ack_requested();
  bool ack_requested() const;
  void set_ack_requested(bool value);
  private:
  bool _internal_ack_requested() const;
  void _internal_set_ack_requested(bool value);
  public:
 
  // required uint32 frame_start = 4 [(.dccl.field) = {
  bool has_frame_start() const;
  private:
  bool _internal_has_frame_start() const;
  public:
  void clear_frame_start();
  uint32_t frame_start() const;
  void set_frame_start(uint32_t value);
  private:
  uint32_t _internal_frame_start() const;
  void _internal_set_frame_start(uint32_t value);
  public:
 
  enum DCCLParameters { DCCL_ID = 10,  DCCL_MAX_BYTES = 32 };
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.MMApplicationAck)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart > part_;
    bool ack_requested_;
    uint32_t frame_start_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto;
};
// ===================================================================
 
static const int kConfigFieldNumber = 1000;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::goby::acomms::protobuf::DriverConfig,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::goby::acomms::micromodem::protobuf::Config >, 11, false >
  config;
static const int kTransmissionFieldNumber = 1000;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::goby::acomms::protobuf::ModemTransmission,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::goby::acomms::micromodem::protobuf::Transmission >, 11, false >
  transmission;
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// NarrowBandLBLParams
 
// optional uint32 transmit_freq = 1;
inline bool NarrowBandLBLParams::_internal_has_transmit_freq() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NarrowBandLBLParams::has_transmit_freq() const {
  return _internal_has_transmit_freq();
}
inline void NarrowBandLBLParams::clear_transmit_freq() {
  _impl_.transmit_freq_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t NarrowBandLBLParams::_internal_transmit_freq() const {
  return _impl_.transmit_freq_;
}
inline uint32_t NarrowBandLBLParams::transmit_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.transmit_freq)
  return _internal_transmit_freq();
}
inline void NarrowBandLBLParams::_internal_set_transmit_freq(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.transmit_freq_ = value;
}
inline void NarrowBandLBLParams::set_transmit_freq(uint32_t value) {
  _internal_set_transmit_freq(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.transmit_freq)
}
 
// optional uint32 transmit_ping_ms = 2;
inline bool NarrowBandLBLParams::_internal_has_transmit_ping_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NarrowBandLBLParams::has_transmit_ping_ms() const {
  return _internal_has_transmit_ping_ms();
}
inline void NarrowBandLBLParams::clear_transmit_ping_ms() {
  _impl_.transmit_ping_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t NarrowBandLBLParams::_internal_transmit_ping_ms() const {
  return _impl_.transmit_ping_ms_;
}
inline uint32_t NarrowBandLBLParams::transmit_ping_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.transmit_ping_ms)
  return _internal_transmit_ping_ms();
}
inline void NarrowBandLBLParams::_internal_set_transmit_ping_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.transmit_ping_ms_ = value;
}
inline void NarrowBandLBLParams::set_transmit_ping_ms(uint32_t value) {
  _internal_set_transmit_ping_ms(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.transmit_ping_ms)
}
 
// repeated uint32 receive_freq = 3;
inline int NarrowBandLBLParams::_internal_receive_freq_size() const {
  return _impl_.receive_freq_.size();
}
inline int NarrowBandLBLParams::receive_freq_size() const {
  return _internal_receive_freq_size();
}
inline void NarrowBandLBLParams::clear_receive_freq() {
  _impl_.receive_freq_.Clear();
}
inline uint32_t NarrowBandLBLParams::_internal_receive_freq(int index) const {
  return _impl_.receive_freq_.Get(index);
}
inline uint32_t NarrowBandLBLParams::receive_freq(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_freq)
  return _internal_receive_freq(index);
}
inline void NarrowBandLBLParams::set_receive_freq(int index, uint32_t value) {
  _impl_.receive_freq_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_freq)
}
inline void NarrowBandLBLParams::_internal_add_receive_freq(uint32_t value) {
  _impl_.receive_freq_.Add(value);
}
inline void NarrowBandLBLParams::add_receive_freq(uint32_t value) {
  _internal_add_receive_freq(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_freq)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
NarrowBandLBLParams::_internal_receive_freq() const {
  return _impl_.receive_freq_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
NarrowBandLBLParams::receive_freq() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_freq)
  return _internal_receive_freq();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
NarrowBandLBLParams::_internal_mutable_receive_freq() {
  return &_impl_.receive_freq_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
NarrowBandLBLParams::mutable_receive_freq() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_freq)
  return _internal_mutable_receive_freq();
}
 
// optional uint32 receive_ping_ms = 4;
inline bool NarrowBandLBLParams::_internal_has_receive_ping_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NarrowBandLBLParams::has_receive_ping_ms() const {
  return _internal_has_receive_ping_ms();
}
inline void NarrowBandLBLParams::clear_receive_ping_ms() {
  _impl_.receive_ping_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t NarrowBandLBLParams::_internal_receive_ping_ms() const {
  return _impl_.receive_ping_ms_;
}
inline uint32_t NarrowBandLBLParams::receive_ping_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_ping_ms)
  return _internal_receive_ping_ms();
}
inline void NarrowBandLBLParams::_internal_set_receive_ping_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.receive_ping_ms_ = value;
}
inline void NarrowBandLBLParams::set_receive_ping_ms(uint32_t value) {
  _internal_set_receive_ping_ms(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_ping_ms)
}
 
// optional uint32 turnaround_ms = 5;
inline bool NarrowBandLBLParams::_internal_has_turnaround_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool NarrowBandLBLParams::has_turnaround_ms() const {
  return _internal_has_turnaround_ms();
}
inline void NarrowBandLBLParams::clear_turnaround_ms() {
  _impl_.turnaround_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t NarrowBandLBLParams::_internal_turnaround_ms() const {
  return _impl_.turnaround_ms_;
}
inline uint32_t NarrowBandLBLParams::turnaround_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.turnaround_ms)
  return _internal_turnaround_ms();
}
inline void NarrowBandLBLParams::_internal_set_turnaround_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.turnaround_ms_ = value;
}
inline void NarrowBandLBLParams::set_turnaround_ms(uint32_t value) {
  _internal_set_turnaround_ms(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.turnaround_ms)
}
 
// optional bool transmit_flag = 6 [default = true];
inline bool NarrowBandLBLParams::_internal_has_transmit_flag() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool NarrowBandLBLParams::has_transmit_flag() const {
  return _internal_has_transmit_flag();
}
inline void NarrowBandLBLParams::clear_transmit_flag() {
  _impl_.transmit_flag_ = true;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool NarrowBandLBLParams::_internal_transmit_flag() const {
  return _impl_.transmit_flag_;
}
inline bool NarrowBandLBLParams::transmit_flag() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.transmit_flag)
  return _internal_transmit_flag();
}
inline void NarrowBandLBLParams::_internal_set_transmit_flag(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.transmit_flag_ = value;
}
inline void NarrowBandLBLParams::set_transmit_flag(bool value) {
  _internal_set_transmit_flag(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.transmit_flag)
}
 
// optional uint32 lbl_max_range = 7 [default = 2000];
inline bool NarrowBandLBLParams::_internal_has_lbl_max_range() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool NarrowBandLBLParams::has_lbl_max_range() const {
  return _internal_has_lbl_max_range();
}
inline void NarrowBandLBLParams::clear_lbl_max_range() {
  _impl_.lbl_max_range_ = 2000u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t NarrowBandLBLParams::_internal_lbl_max_range() const {
  return _impl_.lbl_max_range_;
}
inline uint32_t NarrowBandLBLParams::lbl_max_range() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.lbl_max_range)
  return _internal_lbl_max_range();
}
inline void NarrowBandLBLParams::_internal_set_lbl_max_range(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.lbl_max_range_ = value;
}
inline void NarrowBandLBLParams::set_lbl_max_range(uint32_t value) {
  _internal_set_lbl_max_range(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.lbl_max_range)
}
 
// -------------------------------------------------------------------
 
// REMUSLBLParams
 
// optional uint32 enable_beacons = 1 [default = 15];
inline bool REMUSLBLParams::_internal_has_enable_beacons() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool REMUSLBLParams::has_enable_beacons() const {
  return _internal_has_enable_beacons();
}
inline void REMUSLBLParams::clear_enable_beacons() {
  _impl_.enable_beacons_ = 15u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t REMUSLBLParams::_internal_enable_beacons() const {
  return _impl_.enable_beacons_;
}
inline uint32_t REMUSLBLParams::enable_beacons() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.REMUSLBLParams.enable_beacons)
  return _internal_enable_beacons();
}
inline void REMUSLBLParams::_internal_set_enable_beacons(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.enable_beacons_ = value;
}
inline void REMUSLBLParams::set_enable_beacons(uint32_t value) {
  _internal_set_enable_beacons(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.REMUSLBLParams.enable_beacons)
}
 
// optional uint32 turnaround_ms = 2 [default = 50];
inline bool REMUSLBLParams::_internal_has_turnaround_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool REMUSLBLParams::has_turnaround_ms() const {
  return _internal_has_turnaround_ms();
}
inline void REMUSLBLParams::clear_turnaround_ms() {
  _impl_.turnaround_ms_ = 50u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t REMUSLBLParams::_internal_turnaround_ms() const {
  return _impl_.turnaround_ms_;
}
inline uint32_t REMUSLBLParams::turnaround_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.REMUSLBLParams.turnaround_ms)
  return _internal_turnaround_ms();
}
inline void REMUSLBLParams::_internal_set_turnaround_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.turnaround_ms_ = value;
}
inline void REMUSLBLParams::set_turnaround_ms(uint32_t value) {
  _internal_set_turnaround_ms(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.REMUSLBLParams.turnaround_ms)
}
 
// optional uint32 lbl_max_range = 3 [default = 1000];
inline bool REMUSLBLParams::_internal_has_lbl_max_range() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool REMUSLBLParams::has_lbl_max_range() const {
  return _internal_has_lbl_max_range();
}
inline void REMUSLBLParams::clear_lbl_max_range() {
  _impl_.lbl_max_range_ = 1000u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t REMUSLBLParams::_internal_lbl_max_range() const {
  return _impl_.lbl_max_range_;
}
inline uint32_t REMUSLBLParams::lbl_max_range() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.REMUSLBLParams.lbl_max_range)
  return _internal_lbl_max_range();
}
inline void REMUSLBLParams::_internal_set_lbl_max_range(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.lbl_max_range_ = value;
}
inline void REMUSLBLParams::set_lbl_max_range(uint32_t value) {
  _internal_set_lbl_max_range(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.REMUSLBLParams.lbl_max_range)
}
 
// -------------------------------------------------------------------
 
// GenericLBLParams
 
// optional uint32 transmit_freq = 1;
inline bool GenericLBLParams::_internal_has_transmit_freq() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GenericLBLParams::has_transmit_freq() const {
  return _internal_has_transmit_freq();
}
inline void GenericLBLParams::clear_transmit_freq() {
  _impl_.transmit_freq_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t GenericLBLParams::_internal_transmit_freq() const {
  return _impl_.transmit_freq_;
}
inline uint32_t GenericLBLParams::transmit_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.transmit_freq)
  return _internal_transmit_freq();
}
inline void GenericLBLParams::_internal_set_transmit_freq(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.transmit_freq_ = value;
}
inline void GenericLBLParams::set_transmit_freq(uint32_t value) {
  _internal_set_transmit_freq(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.transmit_freq)
}
 
// optional uint32 n_bits = 2;
inline bool GenericLBLParams::_internal_has_n_bits() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool GenericLBLParams::has_n_bits() const {
  return _internal_has_n_bits();
}
inline void GenericLBLParams::clear_n_bits() {
  _impl_.n_bits_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t GenericLBLParams::_internal_n_bits() const {
  return _impl_.n_bits_;
}
inline uint32_t GenericLBLParams::n_bits() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.n_bits)
  return _internal_n_bits();
}
inline void GenericLBLParams::_internal_set_n_bits(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.n_bits_ = value;
}
inline void GenericLBLParams::set_n_bits(uint32_t value) {
  _internal_set_n_bits(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.n_bits)
}
 
// optional uint64 transmit_seq_code = 3;
inline bool GenericLBLParams::_internal_has_transmit_seq_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool GenericLBLParams::has_transmit_seq_code() const {
  return _internal_has_transmit_seq_code();
}
inline void GenericLBLParams::clear_transmit_seq_code() {
  _impl_.transmit_seq_code_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t GenericLBLParams::_internal_transmit_seq_code() const {
  return _impl_.transmit_seq_code_;
}
inline uint64_t GenericLBLParams::transmit_seq_code() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.transmit_seq_code)
  return _internal_transmit_seq_code();
}
inline void GenericLBLParams::_internal_set_transmit_seq_code(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.transmit_seq_code_ = value;
}
inline void GenericLBLParams::set_transmit_seq_code(uint64_t value) {
  _internal_set_transmit_seq_code(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.transmit_seq_code)
}
 
// optional uint32 receive_freq = 4;
inline bool GenericLBLParams::_internal_has_receive_freq() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool GenericLBLParams::has_receive_freq() const {
  return _internal_has_receive_freq();
}
inline void GenericLBLParams::clear_receive_freq() {
  _impl_.receive_freq_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t GenericLBLParams::_internal_receive_freq() const {
  return _impl_.receive_freq_;
}
inline uint32_t GenericLBLParams::receive_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_freq)
  return _internal_receive_freq();
}
inline void GenericLBLParams::_internal_set_receive_freq(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.receive_freq_ = value;
}
inline void GenericLBLParams::set_receive_freq(uint32_t value) {
  _internal_set_receive_freq(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_freq)
}
 
// repeated uint64 receive_seq_code = 5;
inline int GenericLBLParams::_internal_receive_seq_code_size() const {
  return _impl_.receive_seq_code_.size();
}
inline int GenericLBLParams::receive_seq_code_size() const {
  return _internal_receive_seq_code_size();
}
inline void GenericLBLParams::clear_receive_seq_code() {
  _impl_.receive_seq_code_.Clear();
}
inline uint64_t GenericLBLParams::_internal_receive_seq_code(int index) const {
  return _impl_.receive_seq_code_.Get(index);
}
inline uint64_t GenericLBLParams::receive_seq_code(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_seq_code)
  return _internal_receive_seq_code(index);
}
inline void GenericLBLParams::set_receive_seq_code(int index, uint64_t value) {
  _impl_.receive_seq_code_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_seq_code)
}
inline void GenericLBLParams::_internal_add_receive_seq_code(uint64_t value) {
  _impl_.receive_seq_code_.Add(value);
}
inline void GenericLBLParams::add_receive_seq_code(uint64_t value) {
  _internal_add_receive_seq_code(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_seq_code)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
GenericLBLParams::_internal_receive_seq_code() const {
  return _impl_.receive_seq_code_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
GenericLBLParams::receive_seq_code() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_seq_code)
  return _internal_receive_seq_code();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
GenericLBLParams::_internal_mutable_receive_seq_code() {
  return &_impl_.receive_seq_code_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
GenericLBLParams::mutable_receive_seq_code() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_seq_code)
  return _internal_mutable_receive_seq_code();
}
 
// optional uint32 bandwidth = 6;
inline bool GenericLBLParams::_internal_has_bandwidth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool GenericLBLParams::has_bandwidth() const {
  return _internal_has_bandwidth();
}
inline void GenericLBLParams::clear_bandwidth() {
  _impl_.bandwidth_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t GenericLBLParams::_internal_bandwidth() const {
  return _impl_.bandwidth_;
}
inline uint32_t GenericLBLParams::bandwidth() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.bandwidth)
  return _internal_bandwidth();
}
inline void GenericLBLParams::_internal_set_bandwidth(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.bandwidth_ = value;
}
inline void GenericLBLParams::set_bandwidth(uint32_t value) {
  _internal_set_bandwidth(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.bandwidth)
}
 
// optional uint32 turnaround_ms = 7;
inline bool GenericLBLParams::_internal_has_turnaround_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool GenericLBLParams::has_turnaround_ms() const {
  return _internal_has_turnaround_ms();
}
inline void GenericLBLParams::clear_turnaround_ms() {
  _impl_.turnaround_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t GenericLBLParams::_internal_turnaround_ms() const {
  return _impl_.turnaround_ms_;
}
inline uint32_t GenericLBLParams::turnaround_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.turnaround_ms)
  return _internal_turnaround_ms();
}
inline void GenericLBLParams::_internal_set_turnaround_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.turnaround_ms_ = value;
}
inline void GenericLBLParams::set_turnaround_ms(uint32_t value) {
  _internal_set_turnaround_ms(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.turnaround_ms)
}
 
// optional uint32 lbl_max_range = 8 [default = 2000];
inline bool GenericLBLParams::_internal_has_lbl_max_range() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool GenericLBLParams::has_lbl_max_range() const {
  return _internal_has_lbl_max_range();
}
inline void GenericLBLParams::clear_lbl_max_range() {
  _impl_.lbl_max_range_ = 2000u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t GenericLBLParams::_internal_lbl_max_range() const {
  return _impl_.lbl_max_range_;
}
inline uint32_t GenericLBLParams::lbl_max_range() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.lbl_max_range)
  return _internal_lbl_max_range();
}
inline void GenericLBLParams::_internal_set_lbl_max_range(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.lbl_max_range_ = value;
}
inline void GenericLBLParams::set_lbl_max_range(uint32_t value) {
  _internal_set_lbl_max_range(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.lbl_max_range)
}
 
// -------------------------------------------------------------------
 
// FMSweepParams
 
// required double start_freq = 1;
inline bool FMSweepParams::_internal_has_start_freq() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool FMSweepParams::has_start_freq() const {
  return _internal_has_start_freq();
}
inline void FMSweepParams::clear_start_freq() {
  _impl_.start_freq_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline double FMSweepParams::_internal_start_freq() const {
  return _impl_.start_freq_;
}
inline double FMSweepParams::start_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.FMSweepParams.start_freq)
  return _internal_start_freq();
}
inline void FMSweepParams::_internal_set_start_freq(double value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.start_freq_ = value;
}
inline void FMSweepParams::set_start_freq(double value) {
  _internal_set_start_freq(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.FMSweepParams.start_freq)
}
 
// required double stop_freq = 2;
inline bool FMSweepParams::_internal_has_stop_freq() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool FMSweepParams::has_stop_freq() const {
  return _internal_has_stop_freq();
}
inline void FMSweepParams::clear_stop_freq() {
  _impl_.stop_freq_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline double FMSweepParams::_internal_stop_freq() const {
  return _impl_.stop_freq_;
}
inline double FMSweepParams::stop_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.FMSweepParams.stop_freq)
  return _internal_stop_freq();
}
inline void FMSweepParams::_internal_set_stop_freq(double value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.stop_freq_ = value;
}
inline void FMSweepParams::set_stop_freq(double value) {
  _internal_set_stop_freq(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.FMSweepParams.stop_freq)
}
 
// required double duration_ms = 3;
inline bool FMSweepParams::_internal_has_duration_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool FMSweepParams::has_duration_ms() const {
  return _internal_has_duration_ms();
}
inline void FMSweepParams::clear_duration_ms() {
  _impl_.duration_ms_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline double FMSweepParams::_internal_duration_ms() const {
  return _impl_.duration_ms_;
}
inline double FMSweepParams::duration_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.FMSweepParams.duration_ms)
  return _internal_duration_ms();
}
inline void FMSweepParams::_internal_set_duration_ms(double value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.duration_ms_ = value;
}
inline void FMSweepParams::set_duration_ms(double value) {
  _internal_set_duration_ms(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.FMSweepParams.duration_ms)
}
 
// optional uint32 number_repetitions = 4 [default = 1];
inline bool FMSweepParams::_internal_has_number_repetitions() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool FMSweepParams::has_number_repetitions() const {
  return _internal_has_number_repetitions();
}
inline void FMSweepParams::clear_number_repetitions() {
  _impl_.number_repetitions_ = 1u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t FMSweepParams::_internal_number_repetitions() const {
  return _impl_.number_repetitions_;
}
inline uint32_t FMSweepParams::number_repetitions() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.FMSweepParams.number_repetitions)
  return _internal_number_repetitions();
}
inline void FMSweepParams::_internal_set_number_repetitions(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.number_repetitions_ = value;
}
inline void FMSweepParams::set_number_repetitions(uint32_t value) {
  _internal_set_number_repetitions(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.FMSweepParams.number_repetitions)
}
 
// optional double repetition_period_ms = 5 [default = 1000];
inline bool FMSweepParams::_internal_has_repetition_period_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool FMSweepParams::has_repetition_period_ms() const {
  return _internal_has_repetition_period_ms();
}
inline void FMSweepParams::clear_repetition_period_ms() {
  _impl_.repetition_period_ms_ = 1000;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline double FMSweepParams::_internal_repetition_period_ms() const {
  return _impl_.repetition_period_ms_;
}
inline double FMSweepParams::repetition_period_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.FMSweepParams.repetition_period_ms)
  return _internal_repetition_period_ms();
}
inline void FMSweepParams::_internal_set_repetition_period_ms(double value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.repetition_period_ms_ = value;
}
inline void FMSweepParams::set_repetition_period_ms(double value) {
  _internal_set_repetition_period_ms(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.FMSweepParams.repetition_period_ms)
}
 
// -------------------------------------------------------------------
 
// MSequenceParams
 
// required uint32 seqlen_bits = 1;
inline bool MSequenceParams::_internal_has_seqlen_bits() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MSequenceParams::has_seqlen_bits() const {
  return _internal_has_seqlen_bits();
}
inline void MSequenceParams::clear_seqlen_bits() {
  _impl_.seqlen_bits_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t MSequenceParams::_internal_seqlen_bits() const {
  return _impl_.seqlen_bits_;
}
inline uint32_t MSequenceParams::seqlen_bits() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MSequenceParams.seqlen_bits)
  return _internal_seqlen_bits();
}
inline void MSequenceParams::_internal_set_seqlen_bits(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.seqlen_bits_ = value;
}
inline void MSequenceParams::set_seqlen_bits(uint32_t value) {
  _internal_set_seqlen_bits(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.MSequenceParams.seqlen_bits)
}
 
// required uint32 number_repetitions = 2;
inline bool MSequenceParams::_internal_has_number_repetitions() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MSequenceParams::has_number_repetitions() const {
  return _internal_has_number_repetitions();
}
inline void MSequenceParams::clear_number_repetitions() {
  _impl_.number_repetitions_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t MSequenceParams::_internal_number_repetitions() const {
  return _impl_.number_repetitions_;
}
inline uint32_t MSequenceParams::number_repetitions() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MSequenceParams.number_repetitions)
  return _internal_number_repetitions();
}
inline void MSequenceParams::_internal_set_number_repetitions(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.number_repetitions_ = value;
}
inline void MSequenceParams::set_number_repetitions(uint32_t value) {
  _internal_set_number_repetitions(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.MSequenceParams.number_repetitions)
}
 
// required uint32 carrier_cycles_per_chip = 3;
inline bool MSequenceParams::_internal_has_carrier_cycles_per_chip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MSequenceParams::has_carrier_cycles_per_chip() const {
  return _internal_has_carrier_cycles_per_chip();
}
inline void MSequenceParams::clear_carrier_cycles_per_chip() {
  _impl_.carrier_cycles_per_chip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t MSequenceParams::_internal_carrier_cycles_per_chip() const {
  return _impl_.carrier_cycles_per_chip_;
}
inline uint32_t MSequenceParams::carrier_cycles_per_chip() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MSequenceParams.carrier_cycles_per_chip)
  return _internal_carrier_cycles_per_chip();
}
inline void MSequenceParams::_internal_set_carrier_cycles_per_chip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.carrier_cycles_per_chip_ = value;
}
inline void MSequenceParams::set_carrier_cycles_per_chip(uint32_t value) {
  _internal_set_carrier_cycles_per_chip(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.MSequenceParams.carrier_cycles_per_chip)
}
 
// required uint32 carrier_freq = 4;
inline bool MSequenceParams::_internal_has_carrier_freq() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MSequenceParams::has_carrier_freq() const {
  return _internal_has_carrier_freq();
}
inline void MSequenceParams::clear_carrier_freq() {
  _impl_.carrier_freq_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t MSequenceParams::_internal_carrier_freq() const {
  return _impl_.carrier_freq_;
}
inline uint32_t MSequenceParams::carrier_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MSequenceParams.carrier_freq)
  return _internal_carrier_freq();
}
inline void MSequenceParams::_internal_set_carrier_freq(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.carrier_freq_ = value;
}
inline void MSequenceParams::set_carrier_freq(uint32_t value) {
  _internal_set_carrier_freq(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.MSequenceParams.carrier_freq)
}
 
// -------------------------------------------------------------------
 
// Config_Revision
 
// required int32 mm_major = 1;
inline bool Config_Revision::_internal_has_mm_major() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Config_Revision::has_mm_major() const {
  return _internal_has_mm_major();
}
inline void Config_Revision::clear_mm_major() {
  _impl_.mm_major_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t Config_Revision::_internal_mm_major() const {
  return _impl_.mm_major_;
}
inline int32_t Config_Revision::mm_major() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.Revision.mm_major)
  return _internal_mm_major();
}
inline void Config_Revision::_internal_set_mm_major(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.mm_major_ = value;
}
inline void Config_Revision::set_mm_major(int32_t value) {
  _internal_set_mm_major(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.Revision.mm_major)
}
 
// required int32 mm_minor = 2;
inline bool Config_Revision::_internal_has_mm_minor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Config_Revision::has_mm_minor() const {
  return _internal_has_mm_minor();
}
inline void Config_Revision::clear_mm_minor() {
  _impl_.mm_minor_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t Config_Revision::_internal_mm_minor() const {
  return _impl_.mm_minor_;
}
inline int32_t Config_Revision::mm_minor() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.Revision.mm_minor)
  return _internal_mm_minor();
}
inline void Config_Revision::_internal_set_mm_minor(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mm_minor_ = value;
}
inline void Config_Revision::set_mm_minor(int32_t value) {
  _internal_set_mm_minor(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.Revision.mm_minor)
}
 
// required int32 mm_patch = 3;
inline bool Config_Revision::_internal_has_mm_patch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Config_Revision::has_mm_patch() const {
  return _internal_has_mm_patch();
}
inline void Config_Revision::clear_mm_patch() {
  _impl_.mm_patch_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t Config_Revision::_internal_mm_patch() const {
  return _impl_.mm_patch_;
}
inline int32_t Config_Revision::mm_patch() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.Revision.mm_patch)
  return _internal_mm_patch();
}
inline void Config_Revision::_internal_set_mm_patch(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.mm_patch_ = value;
}
inline void Config_Revision::set_mm_patch(int32_t value) {
  _internal_set_mm_patch(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.Revision.mm_patch)
}
 
// -------------------------------------------------------------------
 
// Config
 
// optional bool reset_nvram = 1 [default = false];
inline bool Config::_internal_has_reset_nvram() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Config::has_reset_nvram() const {
  return _internal_has_reset_nvram();
}
inline void Config::clear_reset_nvram() {
  _impl_.reset_nvram_ = false;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline bool Config::_internal_reset_nvram() const {
  return _impl_.reset_nvram_;
}
inline bool Config::reset_nvram() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.reset_nvram)
  return _internal_reset_nvram();
}
inline void Config::_internal_set_reset_nvram(bool value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.reset_nvram_ = value;
}
inline void Config::set_reset_nvram(bool value) {
  _internal_set_reset_nvram(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.reset_nvram)
}
 
// repeated string nvram_cfg = 2;
inline int Config::_internal_nvram_cfg_size() const {
  return _impl_.nvram_cfg_.size();
}
inline int Config::nvram_cfg_size() const {
  return _internal_nvram_cfg_size();
}
inline void Config::clear_nvram_cfg() {
  _impl_.nvram_cfg_.Clear();
}
inline std::string* Config::add_nvram_cfg() {
  std::string* _s = _internal_add_nvram_cfg();
  // @@protoc_insertion_point(field_add_mutable:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  return _s;
}
inline const std::string& Config::_internal_nvram_cfg(int index) const {
  return _impl_.nvram_cfg_.Get(index);
}
inline const std::string& Config::nvram_cfg(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  return _internal_nvram_cfg(index);
}
inline std::string* Config::mutable_nvram_cfg(int index) {
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  return _impl_.nvram_cfg_.Mutable(index);
}
inline void Config::set_nvram_cfg(int index, const std::string& value) {
  _impl_.nvram_cfg_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
}
inline void Config::set_nvram_cfg(int index, std::string&& value) {
  _impl_.nvram_cfg_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
}
inline void Config::set_nvram_cfg(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.nvram_cfg_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
}
inline void Config::set_nvram_cfg(int index, const char* value, size_t size) {
  _impl_.nvram_cfg_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
}
inline std::string* Config::_internal_add_nvram_cfg() {
  return _impl_.nvram_cfg_.Add();
}
inline void Config::add_nvram_cfg(const std::string& value) {
  _impl_.nvram_cfg_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
}
inline void Config::add_nvram_cfg(std::string&& value) {
  _impl_.nvram_cfg_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
}
inline void Config::add_nvram_cfg(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.nvram_cfg_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
}
inline void Config::add_nvram_cfg(const char* value, size_t size) {
  _impl_.nvram_cfg_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Config::nvram_cfg() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  return _impl_.nvram_cfg_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Config::mutable_nvram_cfg() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  return &_impl_.nvram_cfg_;
}
 
// optional uint32 hydroid_gateway_id = 3 [default = 0];
inline bool Config::_internal_has_hydroid_gateway_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Config::has_hydroid_gateway_id() const {
  return _internal_has_hydroid_gateway_id();
}
inline void Config::clear_hydroid_gateway_id() {
  _impl_.hydroid_gateway_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t Config::_internal_hydroid_gateway_id() const {
  return _impl_.hydroid_gateway_id_;
}
inline uint32_t Config::hydroid_gateway_id() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.hydroid_gateway_id)
  return _internal_hydroid_gateway_id();
}
inline void Config::_internal_set_hydroid_gateway_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.hydroid_gateway_id_ = value;
}
inline void Config::set_hydroid_gateway_id(uint32_t value) {
  _internal_set_hydroid_gateway_id(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.hydroid_gateway_id)
}
 
// optional .goby.acomms.micromodem.protobuf.NarrowBandLBLParams narrowband_lbl = 4;
inline bool Config::_internal_has_narrowband_lbl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.narrowband_lbl_ != nullptr);
  return value;
}
inline bool Config::has_narrowband_lbl() const {
  return _internal_has_narrowband_lbl();
}
inline void Config::clear_narrowband_lbl() {
  if (_impl_.narrowband_lbl_ != nullptr) _impl_.narrowband_lbl_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& Config::_internal_narrowband_lbl() const {
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* p = _impl_.narrowband_lbl_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams&>(
      ::goby::acomms::micromodem::protobuf::_NarrowBandLBLParams_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& Config::narrowband_lbl() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.narrowband_lbl)
  return _internal_narrowband_lbl();
}
inline void Config::unsafe_arena_set_allocated_narrowband_lbl(
    ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.narrowband_lbl_);
  }
  _impl_.narrowband_lbl_ = narrowband_lbl;
  if (narrowband_lbl) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Config.narrowband_lbl)
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Config::release_narrowband_lbl() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* temp = _impl_.narrowband_lbl_;
  _impl_.narrowband_lbl_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Config::unsafe_arena_release_narrowband_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.narrowband_lbl)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* temp = _impl_.narrowband_lbl_;
  _impl_.narrowband_lbl_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Config::_internal_mutable_narrowband_lbl() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.narrowband_lbl_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::NarrowBandLBLParams>(GetArenaForAllocation());
    _impl_.narrowband_lbl_ = p;
  }
  return _impl_.narrowband_lbl_;
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Config::mutable_narrowband_lbl() {
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* _msg = _internal_mutable_narrowband_lbl();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.narrowband_lbl)
  return _msg;
}
inline void Config::set_allocated_narrowband_lbl(::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.narrowband_lbl_;
  }
  if (narrowband_lbl) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(narrowband_lbl);
    if (message_arena != submessage_arena) {
      narrowband_lbl = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, narrowband_lbl, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.narrowband_lbl_ = narrowband_lbl;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Config.narrowband_lbl)
}
 
// optional .goby.acomms.micromodem.protobuf.REMUSLBLParams remus_lbl = 5;
inline bool Config::_internal_has_remus_lbl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.remus_lbl_ != nullptr);
  return value;
}
inline bool Config::has_remus_lbl() const {
  return _internal_has_remus_lbl();
}
inline void Config::clear_remus_lbl() {
  if (_impl_.remus_lbl_ != nullptr) _impl_.remus_lbl_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& Config::_internal_remus_lbl() const {
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams* p = _impl_.remus_lbl_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::REMUSLBLParams&>(
      ::goby::acomms::micromodem::protobuf::_REMUSLBLParams_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& Config::remus_lbl() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.remus_lbl)
  return _internal_remus_lbl();
}
inline void Config::unsafe_arena_set_allocated_remus_lbl(
    ::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.remus_lbl_);
  }
  _impl_.remus_lbl_ = remus_lbl;
  if (remus_lbl) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Config.remus_lbl)
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Config::release_remus_lbl() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* temp = _impl_.remus_lbl_;
  _impl_.remus_lbl_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Config::unsafe_arena_release_remus_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.remus_lbl)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* temp = _impl_.remus_lbl_;
  _impl_.remus_lbl_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Config::_internal_mutable_remus_lbl() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.remus_lbl_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::REMUSLBLParams>(GetArenaForAllocation());
    _impl_.remus_lbl_ = p;
  }
  return _impl_.remus_lbl_;
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Config::mutable_remus_lbl() {
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* _msg = _internal_mutable_remus_lbl();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.remus_lbl)
  return _msg;
}
inline void Config::set_allocated_remus_lbl(::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.remus_lbl_;
  }
  if (remus_lbl) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(remus_lbl);
    if (message_arena != submessage_arena) {
      remus_lbl = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, remus_lbl, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.remus_lbl_ = remus_lbl;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Config.remus_lbl)
}
 
// optional int32 keep_alive_seconds = 6 [default = 10];
inline bool Config::_internal_has_keep_alive_seconds() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Config::has_keep_alive_seconds() const {
  return _internal_has_keep_alive_seconds();
}
inline void Config::clear_keep_alive_seconds() {
  _impl_.keep_alive_seconds_ = 10;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int32_t Config::_internal_keep_alive_seconds() const {
  return _impl_.keep_alive_seconds_;
}
inline int32_t Config::keep_alive_seconds() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.keep_alive_seconds)
  return _internal_keep_alive_seconds();
}
inline void Config::_internal_set_keep_alive_seconds(int32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.keep_alive_seconds_ = value;
}
inline void Config::set_keep_alive_seconds(int32_t value) {
  _internal_set_keep_alive_seconds(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.keep_alive_seconds)
}
 
// optional int32 allowed_skew_ms = 7 [default = 1000];
inline bool Config::_internal_has_allowed_skew_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Config::has_allowed_skew_ms() const {
  return _internal_has_allowed_skew_ms();
}
inline void Config::clear_allowed_skew_ms() {
  _impl_.allowed_skew_ms_ = 1000;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int32_t Config::_internal_allowed_skew_ms() const {
  return _impl_.allowed_skew_ms_;
}
inline int32_t Config::allowed_skew_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.allowed_skew_ms)
  return _internal_allowed_skew_ms();
}
inline void Config::_internal_set_allowed_skew_ms(int32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.allowed_skew_ms_ = value;
}
inline void Config::set_allowed_skew_ms(int32_t value) {
  _internal_set_allowed_skew_ms(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.allowed_skew_ms)
}
 
// optional .goby.acomms.micromodem.protobuf.GenericLBLParams generic_lbl = 8;
inline bool Config::_internal_has_generic_lbl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.generic_lbl_ != nullptr);
  return value;
}
inline bool Config::has_generic_lbl() const {
  return _internal_has_generic_lbl();
}
inline void Config::clear_generic_lbl() {
  if (_impl_.generic_lbl_ != nullptr) _impl_.generic_lbl_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::goby::acomms::micromodem::protobuf::GenericLBLParams& Config::_internal_generic_lbl() const {
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams* p = _impl_.generic_lbl_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::GenericLBLParams&>(
      ::goby::acomms::micromodem::protobuf::_GenericLBLParams_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::GenericLBLParams& Config::generic_lbl() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.generic_lbl)
  return _internal_generic_lbl();
}
inline void Config::unsafe_arena_set_allocated_generic_lbl(
    ::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.generic_lbl_);
  }
  _impl_.generic_lbl_ = generic_lbl;
  if (generic_lbl) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Config.generic_lbl)
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Config::release_generic_lbl() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* temp = _impl_.generic_lbl_;
  _impl_.generic_lbl_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Config::unsafe_arena_release_generic_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.generic_lbl)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* temp = _impl_.generic_lbl_;
  _impl_.generic_lbl_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Config::_internal_mutable_generic_lbl() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.generic_lbl_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::GenericLBLParams>(GetArenaForAllocation());
    _impl_.generic_lbl_ = p;
  }
  return _impl_.generic_lbl_;
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Config::mutable_generic_lbl() {
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* _msg = _internal_mutable_generic_lbl();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.generic_lbl)
  return _msg;
}
inline void Config::set_allocated_generic_lbl(::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.generic_lbl_;
  }
  if (generic_lbl) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(generic_lbl);
    if (message_arena != submessage_arena) {
      generic_lbl = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, generic_lbl, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.generic_lbl_ = generic_lbl;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Config.generic_lbl)
}
 
// optional .goby.acomms.micromodem.protobuf.FMSweepParams fm_sweep = 9;
inline bool Config::_internal_has_fm_sweep() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fm_sweep_ != nullptr);
  return value;
}
inline bool Config::has_fm_sweep() const {
  return _internal_has_fm_sweep();
}
inline void Config::clear_fm_sweep() {
  if (_impl_.fm_sweep_ != nullptr) _impl_.fm_sweep_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::goby::acomms::micromodem::protobuf::FMSweepParams& Config::_internal_fm_sweep() const {
  const ::goby::acomms::micromodem::protobuf::FMSweepParams* p = _impl_.fm_sweep_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::FMSweepParams&>(
      ::goby::acomms::micromodem::protobuf::_FMSweepParams_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::FMSweepParams& Config::fm_sweep() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.fm_sweep)
  return _internal_fm_sweep();
}
inline void Config::unsafe_arena_set_allocated_fm_sweep(
    ::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fm_sweep_);
  }
  _impl_.fm_sweep_ = fm_sweep;
  if (fm_sweep) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Config.fm_sweep)
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Config::release_fm_sweep() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::goby::acomms::micromodem::protobuf::FMSweepParams* temp = _impl_.fm_sweep_;
  _impl_.fm_sweep_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Config::unsafe_arena_release_fm_sweep() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.fm_sweep)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::goby::acomms::micromodem::protobuf::FMSweepParams* temp = _impl_.fm_sweep_;
  _impl_.fm_sweep_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Config::_internal_mutable_fm_sweep() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.fm_sweep_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::FMSweepParams>(GetArenaForAllocation());
    _impl_.fm_sweep_ = p;
  }
  return _impl_.fm_sweep_;
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Config::mutable_fm_sweep() {
  ::goby::acomms::micromodem::protobuf::FMSweepParams* _msg = _internal_mutable_fm_sweep();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.fm_sweep)
  return _msg;
}
inline void Config::set_allocated_fm_sweep(::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.fm_sweep_;
  }
  if (fm_sweep) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fm_sweep);
    if (message_arena != submessage_arena) {
      fm_sweep = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fm_sweep, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.fm_sweep_ = fm_sweep;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Config.fm_sweep)
}
 
// optional .goby.acomms.micromodem.protobuf.MSequenceParams m_sequence = 10;
inline bool Config::_internal_has_m_sequence() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.m_sequence_ != nullptr);
  return value;
}
inline bool Config::has_m_sequence() const {
  return _internal_has_m_sequence();
}
inline void Config::clear_m_sequence() {
  if (_impl_.m_sequence_ != nullptr) _impl_.m_sequence_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::goby::acomms::micromodem::protobuf::MSequenceParams& Config::_internal_m_sequence() const {
  const ::goby::acomms::micromodem::protobuf::MSequenceParams* p = _impl_.m_sequence_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::MSequenceParams&>(
      ::goby::acomms::micromodem::protobuf::_MSequenceParams_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::MSequenceParams& Config::m_sequence() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.m_sequence)
  return _internal_m_sequence();
}
inline void Config::unsafe_arena_set_allocated_m_sequence(
    ::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.m_sequence_);
  }
  _impl_.m_sequence_ = m_sequence;
  if (m_sequence) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Config.m_sequence)
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Config::release_m_sequence() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::goby::acomms::micromodem::protobuf::MSequenceParams* temp = _impl_.m_sequence_;
  _impl_.m_sequence_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Config::unsafe_arena_release_m_sequence() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.m_sequence)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::goby::acomms::micromodem::protobuf::MSequenceParams* temp = _impl_.m_sequence_;
  _impl_.m_sequence_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Config::_internal_mutable_m_sequence() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.m_sequence_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::MSequenceParams>(GetArenaForAllocation());
    _impl_.m_sequence_ = p;
  }
  return _impl_.m_sequence_;
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Config::mutable_m_sequence() {
  ::goby::acomms::micromodem::protobuf::MSequenceParams* _msg = _internal_mutable_m_sequence();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.m_sequence)
  return _msg;
}
inline void Config::set_allocated_m_sequence(::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.m_sequence_;
  }
  if (m_sequence) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(m_sequence);
    if (message_arena != submessage_arena) {
      m_sequence = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, m_sequence, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.m_sequence_ = m_sequence;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Config.m_sequence)
}
 
// optional bool use_application_acks = 20 [default = false];
inline bool Config::_internal_has_use_application_acks() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Config::has_use_application_acks() const {
  return _internal_has_use_application_acks();
}
inline void Config::clear_use_application_acks() {
  _impl_.use_application_acks_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool Config::_internal_use_application_acks() const {
  return _impl_.use_application_acks_;
}
inline bool Config::use_application_acks() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.use_application_acks)
  return _internal_use_application_acks();
}
inline void Config::_internal_set_use_application_acks(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.use_application_acks_ = value;
}
inline void Config::set_use_application_acks(bool value) {
  _internal_set_use_application_acks(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.use_application_acks)
}
 
// repeated uint32 additional_application_ack_modem_id = 21;
inline int Config::_internal_additional_application_ack_modem_id_size() const {
  return _impl_.additional_application_ack_modem_id_.size();
}
inline int Config::additional_application_ack_modem_id_size() const {
  return _internal_additional_application_ack_modem_id_size();
}
inline void Config::clear_additional_application_ack_modem_id() {
  _impl_.additional_application_ack_modem_id_.Clear();
}
inline uint32_t Config::_internal_additional_application_ack_modem_id(int index) const {
  return _impl_.additional_application_ack_modem_id_.Get(index);
}
inline uint32_t Config::additional_application_ack_modem_id(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.additional_application_ack_modem_id)
  return _internal_additional_application_ack_modem_id(index);
}
inline void Config::set_additional_application_ack_modem_id(int index, uint32_t value) {
  _impl_.additional_application_ack_modem_id_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.additional_application_ack_modem_id)
}
inline void Config::_internal_add_additional_application_ack_modem_id(uint32_t value) {
  _impl_.additional_application_ack_modem_id_.Add(value);
}
inline void Config::add_additional_application_ack_modem_id(uint32_t value) {
  _internal_add_additional_application_ack_modem_id(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Config.additional_application_ack_modem_id)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Config::_internal_additional_application_ack_modem_id() const {
  return _impl_.additional_application_ack_modem_id_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Config::additional_application_ack_modem_id() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.Config.additional_application_ack_modem_id)
  return _internal_additional_application_ack_modem_id();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Config::_internal_mutable_additional_application_ack_modem_id() {
  return &_impl_.additional_application_ack_modem_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Config::mutable_additional_application_ack_modem_id() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.Config.additional_application_ack_modem_id)
  return _internal_mutable_additional_application_ack_modem_id();
}
 
// optional bool query_cfg_on_startup = 22 [default = true];
inline bool Config::_internal_has_query_cfg_on_startup() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Config::has_query_cfg_on_startup() const {
  return _internal_has_query_cfg_on_startup();
}
inline void Config::clear_query_cfg_on_startup() {
  _impl_.query_cfg_on_startup_ = true;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline bool Config::_internal_query_cfg_on_startup() const {
  return _impl_.query_cfg_on_startup_;
}
inline bool Config::query_cfg_on_startup() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.query_cfg_on_startup)
  return _internal_query_cfg_on_startup();
}
inline void Config::_internal_set_query_cfg_on_startup(bool value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.query_cfg_on_startup_ = value;
}
inline void Config::set_query_cfg_on_startup(bool value) {
  _internal_set_query_cfg_on_startup(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.query_cfg_on_startup)
}
 
// optional bool pad_partial_frames = 23 [default = false, (.goby.field) = {
inline bool Config::_internal_has_pad_partial_frames() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Config::has_pad_partial_frames() const {
  return _internal_has_pad_partial_frames();
}
inline void Config::clear_pad_partial_frames() {
  _impl_.pad_partial_frames_ = false;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool Config::_internal_pad_partial_frames() const {
  return _impl_.pad_partial_frames_;
}
inline bool Config::pad_partial_frames() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.pad_partial_frames)
  return _internal_pad_partial_frames();
}
inline void Config::_internal_set_pad_partial_frames(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.pad_partial_frames_ = value;
}
inline void Config::set_pad_partial_frames(bool value) {
  _internal_set_pad_partial_frames(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.pad_partial_frames)
}
 
// optional .goby.acomms.micromodem.protobuf.Config.Revision revision = 30;
inline bool Config::_internal_has_revision() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.revision_ != nullptr);
  return value;
}
inline bool Config::has_revision() const {
  return _internal_has_revision();
}
inline void Config::clear_revision() {
  if (_impl_.revision_ != nullptr) _impl_.revision_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::goby::acomms::micromodem::protobuf::Config_Revision& Config::_internal_revision() const {
  const ::goby::acomms::micromodem::protobuf::Config_Revision* p = _impl_.revision_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::Config_Revision&>(
      ::goby::acomms::micromodem::protobuf::_Config_Revision_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::Config_Revision& Config::revision() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.revision)
  return _internal_revision();
}
inline void Config::unsafe_arena_set_allocated_revision(
    ::goby::acomms::micromodem::protobuf::Config_Revision* revision) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.revision_);
  }
  _impl_.revision_ = revision;
  if (revision) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Config.revision)
}
inline ::goby::acomms::micromodem::protobuf::Config_Revision* Config::release_revision() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::goby::acomms::micromodem::protobuf::Config_Revision* temp = _impl_.revision_;
  _impl_.revision_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::Config_Revision* Config::unsafe_arena_release_revision() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.revision)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::goby::acomms::micromodem::protobuf::Config_Revision* temp = _impl_.revision_;
  _impl_.revision_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::Config_Revision* Config::_internal_mutable_revision() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.revision_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::Config_Revision>(GetArenaForAllocation());
    _impl_.revision_ = p;
  }
  return _impl_.revision_;
}
inline ::goby::acomms::micromodem::protobuf::Config_Revision* Config::mutable_revision() {
  ::goby::acomms::micromodem::protobuf::Config_Revision* _msg = _internal_mutable_revision();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.revision)
  return _msg;
}
inline void Config::set_allocated_revision(::goby::acomms::micromodem::protobuf::Config_Revision* revision) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.revision_;
  }
  if (revision) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(revision);
    if (message_arena != submessage_arena) {
      revision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, revision, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.revision_ = revision;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Config.revision)
}
 
// optional bool use_base64_fdp = 40 [default = false];
inline bool Config::_internal_has_use_base64_fdp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Config::has_use_base64_fdp() const {
  return _internal_has_use_base64_fdp();
}
inline void Config::clear_use_base64_fdp() {
  _impl_.use_base64_fdp_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool Config::_internal_use_base64_fdp() const {
  return _impl_.use_base64_fdp_;
}
inline bool Config::use_base64_fdp() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.use_base64_fdp)
  return _internal_use_base64_fdp();
}
inline void Config::_internal_set_use_base64_fdp(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.use_base64_fdp_ = value;
}
inline void Config::set_use_base64_fdp(bool value) {
  _internal_set_use_base64_fdp(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.use_base64_fdp)
}
 
// -------------------------------------------------------------------
 
// RangingReply
 
// repeated double one_way_travel_time = 1 [(.dccl.field) = {
inline int RangingReply::_internal_one_way_travel_time_size() const {
  return _impl_.one_way_travel_time_.size();
}
inline int RangingReply::one_way_travel_time_size() const {
  return _internal_one_way_travel_time_size();
}
inline void RangingReply::clear_one_way_travel_time() {
  _impl_.one_way_travel_time_.Clear();
}
inline double RangingReply::_internal_one_way_travel_time(int index) const {
  return _impl_.one_way_travel_time_.Get(index);
}
inline double RangingReply::one_way_travel_time(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.RangingReply.one_way_travel_time)
  return _internal_one_way_travel_time(index);
}
inline void RangingReply::set_one_way_travel_time(int index, double value) {
  _impl_.one_way_travel_time_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.RangingReply.one_way_travel_time)
}
inline void RangingReply::_internal_add_one_way_travel_time(double value) {
  _impl_.one_way_travel_time_.Add(value);
}
inline void RangingReply::add_one_way_travel_time(double value) {
  _internal_add_one_way_travel_time(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.RangingReply.one_way_travel_time)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
RangingReply::_internal_one_way_travel_time() const {
  return _impl_.one_way_travel_time_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
RangingReply::one_way_travel_time() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.RangingReply.one_way_travel_time)
  return _internal_one_way_travel_time();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
RangingReply::_internal_mutable_one_way_travel_time() {
  return &_impl_.one_way_travel_time_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
RangingReply::mutable_one_way_travel_time() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.RangingReply.one_way_travel_time)
  return _internal_mutable_one_way_travel_time();
}
 
// optional .goby.acomms.micromodem.protobuf.RangingReply.OWTTAmbiguity ambiguity = 2 [default = OWTT_EXACT];
inline bool RangingReply::_internal_has_ambiguity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool RangingReply::has_ambiguity() const {
  return _internal_has_ambiguity();
}
inline void RangingReply::clear_ambiguity() {
  _impl_.ambiguity_ = 1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity RangingReply::_internal_ambiguity() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity >(_impl_.ambiguity_);
}
inline ::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity RangingReply::ambiguity() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.RangingReply.ambiguity)
  return _internal_ambiguity();
}
inline void RangingReply::_internal_set_ambiguity(::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity value) {
  assert(::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.ambiguity_ = value;
}
inline void RangingReply::set_ambiguity(::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity value) {
  _internal_set_ambiguity(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.RangingReply.ambiguity)
}
 
// optional bool is_one_way_synchronous = 3 [default = false];
inline bool RangingReply::_internal_has_is_one_way_synchronous() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RangingReply::has_is_one_way_synchronous() const {
  return _internal_has_is_one_way_synchronous();
}
inline void RangingReply::clear_is_one_way_synchronous() {
  _impl_.is_one_way_synchronous_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool RangingReply::_internal_is_one_way_synchronous() const {
  return _impl_.is_one_way_synchronous_;
}
inline bool RangingReply::is_one_way_synchronous() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.RangingReply.is_one_way_synchronous)
  return _internal_is_one_way_synchronous();
}
inline void RangingReply::_internal_set_is_one_way_synchronous(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.is_one_way_synchronous_ = value;
}
inline void RangingReply::set_is_one_way_synchronous(bool value) {
  _internal_set_is_one_way_synchronous(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.RangingReply.is_one_way_synchronous)
}
 
// optional .goby.acomms.micromodem.protobuf.ClockMode receiver_clk_mode = 4 [default = NO_SYNC_TO_PPS_AND_CCCLK_BAD];
inline bool RangingReply::_internal_has_receiver_clk_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RangingReply::has_receiver_clk_mode() const {
  return _internal_has_receiver_clk_mode();
}
inline void RangingReply::clear_receiver_clk_mode() {
  _impl_.receiver_clk_mode_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::goby::acomms::micromodem::protobuf::ClockMode RangingReply::_internal_receiver_clk_mode() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::ClockMode >(_impl_.receiver_clk_mode_);
}
inline ::goby::acomms::micromodem::protobuf::ClockMode RangingReply::receiver_clk_mode() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.RangingReply.receiver_clk_mode)
  return _internal_receiver_clk_mode();
}
inline void RangingReply::_internal_set_receiver_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  assert(::goby::acomms::micromodem::protobuf::ClockMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.receiver_clk_mode_ = value;
}
inline void RangingReply::set_receiver_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  _internal_set_receiver_clk_mode(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.RangingReply.receiver_clk_mode)
}
 
// optional .goby.acomms.micromodem.protobuf.ClockMode sender_clk_mode = 5 [default = NO_SYNC_TO_PPS_AND_CCCLK_BAD];
inline bool RangingReply::_internal_has_sender_clk_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool RangingReply::has_sender_clk_mode() const {
  return _internal_has_sender_clk_mode();
}
inline void RangingReply::clear_sender_clk_mode() {
  _impl_.sender_clk_mode_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::goby::acomms::micromodem::protobuf::ClockMode RangingReply::_internal_sender_clk_mode() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::ClockMode >(_impl_.sender_clk_mode_);
}
inline ::goby::acomms::micromodem::protobuf::ClockMode RangingReply::sender_clk_mode() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.RangingReply.sender_clk_mode)
  return _internal_sender_clk_mode();
}
inline void RangingReply::_internal_set_sender_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  assert(::goby::acomms::micromodem::protobuf::ClockMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.sender_clk_mode_ = value;
}
inline void RangingReply::set_sender_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  _internal_set_sender_clk_mode(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.RangingReply.sender_clk_mode)
}
 
// -------------------------------------------------------------------
 
// ReceiveStatistics
 
// required .goby.acomms.micromodem.protobuf.ReceiveMode mode = 1;
inline bool ReceiveStatistics::_internal_has_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_mode() const {
  return _internal_has_mode();
}
inline void ReceiveStatistics::clear_mode() {
  _impl_.mode_ = -1;
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline ::goby::acomms::micromodem::protobuf::ReceiveMode ReceiveStatistics::_internal_mode() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::ReceiveMode >(_impl_.mode_);
}
inline ::goby::acomms::micromodem::protobuf::ReceiveMode ReceiveStatistics::mode() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.mode)
  return _internal_mode();
}
inline void ReceiveStatistics::_internal_set_mode(::goby::acomms::micromodem::protobuf::ReceiveMode value) {
  assert(::goby::acomms::micromodem::protobuf::ReceiveMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x10000000u;
  _impl_.mode_ = value;
}
inline void ReceiveStatistics::set_mode(::goby::acomms::micromodem::protobuf::ReceiveMode value) {
  _internal_set_mode(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.mode)
}
 
// required uint64 time = 2 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_time() const {
  return _internal_has_time();
}
inline void ReceiveStatistics::clear_time() {
  _impl_.time_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t ReceiveStatistics::_internal_time() const {
  return _impl_.time_;
}
inline uint64_t ReceiveStatistics::time() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.time)
  return _internal_time();
}
inline void ReceiveStatistics::_internal_set_time(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.time_ = value;
}
inline void ReceiveStatistics::set_time(uint64_t value) {
  _internal_set_time(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.time)
}
 
// required .goby.acomms.micromodem.protobuf.ClockMode clock_mode = 3;
inline bool ReceiveStatistics::_internal_has_clock_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_clock_mode() const {
  return _internal_has_clock_mode();
}
inline void ReceiveStatistics::clear_clock_mode() {
  _impl_.clock_mode_ = -1;
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline ::goby::acomms::micromodem::protobuf::ClockMode ReceiveStatistics::_internal_clock_mode() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::ClockMode >(_impl_.clock_mode_);
}
inline ::goby::acomms::micromodem::protobuf::ClockMode ReceiveStatistics::clock_mode() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.clock_mode)
  return _internal_clock_mode();
}
inline void ReceiveStatistics::_internal_set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  assert(::goby::acomms::micromodem::protobuf::ClockMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x20000000u;
  _impl_.clock_mode_ = value;
}
inline void ReceiveStatistics::set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  _internal_set_clock_mode(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.clock_mode)
}
 
// optional int32 mfd_peak = 4 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_mfd_peak() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_mfd_peak() const {
  return _internal_has_mfd_peak();
}
inline void ReceiveStatistics::clear_mfd_peak() {
  _impl_.mfd_peak_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t ReceiveStatistics::_internal_mfd_peak() const {
  return _impl_.mfd_peak_;
}
inline int32_t ReceiveStatistics::mfd_peak() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.mfd_peak)
  return _internal_mfd_peak();
}
inline void ReceiveStatistics::_internal_set_mfd_peak(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.mfd_peak_ = value;
}
inline void ReceiveStatistics::set_mfd_peak(int32_t value) {
  _internal_set_mfd_peak(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.mfd_peak)
}
 
// required int32 mfd_power = 5 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_mfd_power() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_mfd_power() const {
  return _internal_has_mfd_power();
}
inline void ReceiveStatistics::clear_mfd_power() {
  _impl_.mfd_power_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t ReceiveStatistics::_internal_mfd_power() const {
  return _impl_.mfd_power_;
}
inline int32_t ReceiveStatistics::mfd_power() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.mfd_power)
  return _internal_mfd_power();
}
inline void ReceiveStatistics::_internal_set_mfd_power(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.mfd_power_ = value;
}
inline void ReceiveStatistics::set_mfd_power(int32_t value) {
  _internal_set_mfd_power(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.mfd_power)
}
 
// required int32 mfd_ratio = 6 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_mfd_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_mfd_ratio() const {
  return _internal_has_mfd_ratio();
}
inline void ReceiveStatistics::clear_mfd_ratio() {
  _impl_.mfd_ratio_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t ReceiveStatistics::_internal_mfd_ratio() const {
  return _impl_.mfd_ratio_;
}
inline int32_t ReceiveStatistics::mfd_ratio() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.mfd_ratio)
  return _internal_mfd_ratio();
}
inline void ReceiveStatistics::_internal_set_mfd_ratio(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.mfd_ratio_ = value;
}
inline void ReceiveStatistics::set_mfd_ratio(int32_t value) {
  _internal_set_mfd_ratio(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.mfd_ratio)
}
 
// optional int32 spl = 7 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_spl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_spl() const {
  return _internal_has_spl();
}
inline void ReceiveStatistics::clear_spl() {
  _impl_.spl_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t ReceiveStatistics::_internal_spl() const {
  return _impl_.spl_;
}
inline int32_t ReceiveStatistics::spl() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.spl)
  return _internal_spl();
}
inline void ReceiveStatistics::_internal_set_spl(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.spl_ = value;
}
inline void ReceiveStatistics::set_spl(int32_t value) {
  _internal_set_spl(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.spl)
}
 
// optional int32 shf_agn = 8 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_shf_agn() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_shf_agn() const {
  return _internal_has_shf_agn();
}
inline void ReceiveStatistics::clear_shf_agn() {
  _impl_.shf_agn_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t ReceiveStatistics::_internal_shf_agn() const {
  return _impl_.shf_agn_;
}
inline int32_t ReceiveStatistics::shf_agn() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_agn)
  return _internal_shf_agn();
}
inline void ReceiveStatistics::_internal_set_shf_agn(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.shf_agn_ = value;
}
inline void ReceiveStatistics::set_shf_agn(int32_t value) {
  _internal_set_shf_agn(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_agn)
}
 
// optional int32 shf_ainpshift = 9 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_shf_ainpshift() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_shf_ainpshift() const {
  return _internal_has_shf_ainpshift();
}
inline void ReceiveStatistics::clear_shf_ainpshift() {
  _impl_.shf_ainpshift_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t ReceiveStatistics::_internal_shf_ainpshift() const {
  return _impl_.shf_ainpshift_;
}
inline int32_t ReceiveStatistics::shf_ainpshift() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_ainpshift)
  return _internal_shf_ainpshift();
}
inline void ReceiveStatistics::_internal_set_shf_ainpshift(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.shf_ainpshift_ = value;
}
inline void ReceiveStatistics::set_shf_ainpshift(int32_t value) {
  _internal_set_shf_ainpshift(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_ainpshift)
}
 
// optional int32 shf_ainshift = 10 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_shf_ainshift() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_shf_ainshift() const {
  return _internal_has_shf_ainshift();
}
inline void ReceiveStatistics::clear_shf_ainshift() {
  _impl_.shf_ainshift_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t ReceiveStatistics::_internal_shf_ainshift() const {
  return _impl_.shf_ainshift_;
}
inline int32_t ReceiveStatistics::shf_ainshift() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_ainshift)
  return _internal_shf_ainshift();
}
inline void ReceiveStatistics::_internal_set_shf_ainshift(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.shf_ainshift_ = value;
}
inline void ReceiveStatistics::set_shf_ainshift(int32_t value) {
  _internal_set_shf_ainshift(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_ainshift)
}
 
// optional int32 shf_mfdshift = 11 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_shf_mfdshift() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_shf_mfdshift() const {
  return _internal_has_shf_mfdshift();
}
inline void ReceiveStatistics::clear_shf_mfdshift() {
  _impl_.shf_mfdshift_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t ReceiveStatistics::_internal_shf_mfdshift() const {
  return _impl_.shf_mfdshift_;
}
inline int32_t ReceiveStatistics::shf_mfdshift() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_mfdshift)
  return _internal_shf_mfdshift();
}
inline void ReceiveStatistics::_internal_set_shf_mfdshift(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.shf_mfdshift_ = value;
}
inline void ReceiveStatistics::set_shf_mfdshift(int32_t value) {
  _internal_set_shf_mfdshift(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_mfdshift)
}
 
// optional int32 shf_p2bshift = 12 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_shf_p2bshift() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_shf_p2bshift() const {
  return _internal_has_shf_p2bshift();
}
inline void ReceiveStatistics::clear_shf_p2bshift() {
  _impl_.shf_p2bshift_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline int32_t ReceiveStatistics::_internal_shf_p2bshift() const {
  return _impl_.shf_p2bshift_;
}
inline int32_t ReceiveStatistics::shf_p2bshift() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_p2bshift)
  return _internal_shf_p2bshift();
}
inline void ReceiveStatistics::_internal_set_shf_p2bshift(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.shf_p2bshift_ = value;
}
inline void ReceiveStatistics::set_shf_p2bshift(int32_t value) {
  _internal_set_shf_p2bshift(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_p2bshift)
}
 
// required int32 rate = 13 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_rate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_rate() const {
  return _internal_has_rate();
}
inline void ReceiveStatistics::clear_rate() {
  _impl_.rate_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int32_t ReceiveStatistics::_internal_rate() const {
  return _impl_.rate_;
}
inline int32_t ReceiveStatistics::rate() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.rate)
  return _internal_rate();
}
inline void ReceiveStatistics::_internal_set_rate(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.rate_ = value;
}
inline void ReceiveStatistics::set_rate(int32_t value) {
  _internal_set_rate(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.rate)
}
 
// required int32 source = 14 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_source() const {
  return _internal_has_source();
}
inline void ReceiveStatistics::clear_source() {
  _impl_.source_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int32_t ReceiveStatistics::_internal_source() const {
  return _impl_.source_;
}
inline int32_t ReceiveStatistics::source() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.source)
  return _internal_source();
}
inline void ReceiveStatistics::_internal_set_source(int32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.source_ = value;
}
inline void ReceiveStatistics::set_source(int32_t value) {
  _internal_set_source(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.source)
}
 
// required int32 dest = 15 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_dest() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_dest() const {
  return _internal_has_dest();
}
inline void ReceiveStatistics::clear_dest() {
  _impl_.dest_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int32_t ReceiveStatistics::_internal_dest() const {
  return _impl_.dest_;
}
inline int32_t ReceiveStatistics::dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.dest)
  return _internal_dest();
}
inline void ReceiveStatistics::_internal_set_dest(int32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.dest_ = value;
}
inline void ReceiveStatistics::set_dest(int32_t value) {
  _internal_set_dest(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.dest)
}
 
// required .goby.acomms.micromodem.protobuf.PSKErrorCode psk_error_code = 16;
inline bool ReceiveStatistics::_internal_has_psk_error_code() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_psk_error_code() const {
  return _internal_has_psk_error_code();
}
inline void ReceiveStatistics::clear_psk_error_code() {
  _impl_.psk_error_code_ = -1;
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline ::goby::acomms::micromodem::protobuf::PSKErrorCode ReceiveStatistics::_internal_psk_error_code() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::PSKErrorCode >(_impl_.psk_error_code_);
}
inline ::goby::acomms::micromodem::protobuf::PSKErrorCode ReceiveStatistics::psk_error_code() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.psk_error_code)
  return _internal_psk_error_code();
}
inline void ReceiveStatistics::_internal_set_psk_error_code(::goby::acomms::micromodem::protobuf::PSKErrorCode value) {
  assert(::goby::acomms::micromodem::protobuf::PSKErrorCode_IsValid(value));
  _impl_._has_bits_[0] |= 0x40000000u;
  _impl_.psk_error_code_ = value;
}
inline void ReceiveStatistics::set_psk_error_code(::goby::acomms::micromodem::protobuf::PSKErrorCode value) {
  _internal_set_psk_error_code(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.psk_error_code)
}
 
// required .goby.acomms.micromodem.protobuf.PacketType packet_type = 17;
inline bool ReceiveStatistics::_internal_has_packet_type() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_packet_type() const {
  return _internal_has_packet_type();
}
inline void ReceiveStatistics::clear_packet_type() {
  _impl_.packet_type_ = -1;
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline ::goby::acomms::micromodem::protobuf::PacketType ReceiveStatistics::_internal_packet_type() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::PacketType >(_impl_.packet_type_);
}
inline ::goby::acomms::micromodem::protobuf::PacketType ReceiveStatistics::packet_type() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.packet_type)
  return _internal_packet_type();
}
inline void ReceiveStatistics::_internal_set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value) {
  assert(::goby::acomms::micromodem::protobuf::PacketType_IsValid(value));
  _impl_._has_bits_[0] |= 0x80000000u;
  _impl_.packet_type_ = value;
}
inline void ReceiveStatistics::set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value) {
  _internal_set_packet_type(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.packet_type)
}
 
// required int32 number_frames = 18 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_number_frames() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_number_frames() const {
  return _internal_has_number_frames();
}
inline void ReceiveStatistics::clear_number_frames() {
  _impl_.number_frames_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline int32_t ReceiveStatistics::_internal_number_frames() const {
  return _impl_.number_frames_;
}
inline int32_t ReceiveStatistics::number_frames() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.number_frames)
  return _internal_number_frames();
}
inline void ReceiveStatistics::_internal_set_number_frames(int32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.number_frames_ = value;
}
inline void ReceiveStatistics::set_number_frames(int32_t value) {
  _internal_set_number_frames(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.number_frames)
}
 
// required int32 number_bad_frames = 19 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_number_bad_frames() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_number_bad_frames() const {
  return _internal_has_number_bad_frames();
}
inline void ReceiveStatistics::clear_number_bad_frames() {
  _impl_.number_bad_frames_ = 0;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline int32_t ReceiveStatistics::_internal_number_bad_frames() const {
  return _impl_.number_bad_frames_;
}
inline int32_t ReceiveStatistics::number_bad_frames() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.number_bad_frames)
  return _internal_number_bad_frames();
}
inline void ReceiveStatistics::_internal_set_number_bad_frames(int32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.number_bad_frames_ = value;
}
inline void ReceiveStatistics::set_number_bad_frames(int32_t value) {
  _internal_set_number_bad_frames(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.number_bad_frames)
}
 
// required int32 snr_rss = 20 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_snr_rss() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_snr_rss() const {
  return _internal_has_snr_rss();
}
inline void ReceiveStatistics::clear_snr_rss() {
  _impl_.snr_rss_ = 0;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline int32_t ReceiveStatistics::_internal_snr_rss() const {
  return _impl_.snr_rss_;
}
inline int32_t ReceiveStatistics::snr_rss() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_rss)
  return _internal_snr_rss();
}
inline void ReceiveStatistics::_internal_set_snr_rss(int32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.snr_rss_ = value;
}
inline void ReceiveStatistics::set_snr_rss(int32_t value) {
  _internal_set_snr_rss(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_rss)
}
 
// required int32 snr_in = 21 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_snr_in() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_snr_in() const {
  return _internal_has_snr_in();
}
inline void ReceiveStatistics::clear_snr_in() {
  _impl_.snr_in_ = 0;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline int32_t ReceiveStatistics::_internal_snr_in() const {
  return _impl_.snr_in_;
}
inline int32_t ReceiveStatistics::snr_in() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_in)
  return _internal_snr_in();
}
inline void ReceiveStatistics::_internal_set_snr_in(int32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.snr_in_ = value;
}
inline void ReceiveStatistics::set_snr_in(int32_t value) {
  _internal_set_snr_in(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_in)
}
 
// required int32 snr_out = 22 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_snr_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_snr_out() const {
  return _internal_has_snr_out();
}
inline void ReceiveStatistics::clear_snr_out() {
  _impl_.snr_out_ = 0;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline int32_t ReceiveStatistics::_internal_snr_out() const {
  return _impl_.snr_out_;
}
inline int32_t ReceiveStatistics::snr_out() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_out)
  return _internal_snr_out();
}
inline void ReceiveStatistics::_internal_set_snr_out(int32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.snr_out_ = value;
}
inline void ReceiveStatistics::set_snr_out(int32_t value) {
  _internal_set_snr_out(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_out)
}
 
// required int32 snr_symbols = 23 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_snr_symbols() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_snr_symbols() const {
  return _internal_has_snr_symbols();
}
inline void ReceiveStatistics::clear_snr_symbols() {
  _impl_.snr_symbols_ = 0;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline int32_t ReceiveStatistics::_internal_snr_symbols() const {
  return _impl_.snr_symbols_;
}
inline int32_t ReceiveStatistics::snr_symbols() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_symbols)
  return _internal_snr_symbols();
}
inline void ReceiveStatistics::_internal_set_snr_symbols(int32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.snr_symbols_ = value;
}
inline void ReceiveStatistics::set_snr_symbols(int32_t value) {
  _internal_set_snr_symbols(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_symbols)
}
 
// required int32 mse_equalizer = 24 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_mse_equalizer() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_mse_equalizer() const {
  return _internal_has_mse_equalizer();
}
inline void ReceiveStatistics::clear_mse_equalizer() {
  _impl_.mse_equalizer_ = 0;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline int32_t ReceiveStatistics::_internal_mse_equalizer() const {
  return _impl_.mse_equalizer_;
}
inline int32_t ReceiveStatistics::mse_equalizer() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.mse_equalizer)
  return _internal_mse_equalizer();
}
inline void ReceiveStatistics::_internal_set_mse_equalizer(int32_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.mse_equalizer_ = value;
}
inline void ReceiveStatistics::set_mse_equalizer(int32_t value) {
  _internal_set_mse_equalizer(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.mse_equalizer)
}
 
// required int32 data_quality_factor = 25 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_data_quality_factor() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_data_quality_factor() const {
  return _internal_has_data_quality_factor();
}
inline void ReceiveStatistics::clear_data_quality_factor() {
  _impl_.data_quality_factor_ = 0;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline int32_t ReceiveStatistics::_internal_data_quality_factor() const {
  return _impl_.data_quality_factor_;
}
inline int32_t ReceiveStatistics::data_quality_factor() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.data_quality_factor)
  return _internal_data_quality_factor();
}
inline void ReceiveStatistics::_internal_set_data_quality_factor(int32_t value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.data_quality_factor_ = value;
}
inline void ReceiveStatistics::set_data_quality_factor(int32_t value) {
  _internal_set_data_quality_factor(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.data_quality_factor)
}
 
// required double doppler = 26 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_doppler() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_doppler() const {
  return _internal_has_doppler();
}
inline void ReceiveStatistics::clear_doppler() {
  _impl_.doppler_ = 0;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline double ReceiveStatistics::_internal_doppler() const {
  return _impl_.doppler_;
}
inline double ReceiveStatistics::doppler() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.doppler)
  return _internal_doppler();
}
inline void ReceiveStatistics::_internal_set_doppler(double value) {
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.doppler_ = value;
}
inline void ReceiveStatistics::set_doppler(double value) {
  _internal_set_doppler(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.doppler)
}
 
// required int32 stddev_noise = 27 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_stddev_noise() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_stddev_noise() const {
  return _internal_has_stddev_noise();
}
inline void ReceiveStatistics::clear_stddev_noise() {
  _impl_.stddev_noise_ = 0;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline int32_t ReceiveStatistics::_internal_stddev_noise() const {
  return _impl_.stddev_noise_;
}
inline int32_t ReceiveStatistics::stddev_noise() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.stddev_noise)
  return _internal_stddev_noise();
}
inline void ReceiveStatistics::_internal_set_stddev_noise(int32_t value) {
  _impl_._has_bits_[0] |= 0x00800000u;
  _impl_.stddev_noise_ = value;
}
inline void ReceiveStatistics::set_stddev_noise(int32_t value) {
  _internal_set_stddev_noise(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.stddev_noise)
}
 
// required int32 carrier_freq = 28 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_carrier_freq() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_carrier_freq() const {
  return _internal_has_carrier_freq();
}
inline void ReceiveStatistics::clear_carrier_freq() {
  _impl_.carrier_freq_ = 0;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline int32_t ReceiveStatistics::_internal_carrier_freq() const {
  return _impl_.carrier_freq_;
}
inline int32_t ReceiveStatistics::carrier_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.carrier_freq)
  return _internal_carrier_freq();
}
inline void ReceiveStatistics::_internal_set_carrier_freq(int32_t value) {
  _impl_._has_bits_[0] |= 0x01000000u;
  _impl_.carrier_freq_ = value;
}
inline void ReceiveStatistics::set_carrier_freq(int32_t value) {
  _internal_set_carrier_freq(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.carrier_freq)
}
 
// required int32 bandwidth = 29 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_bandwidth() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_bandwidth() const {
  return _internal_has_bandwidth();
}
inline void ReceiveStatistics::clear_bandwidth() {
  _impl_.bandwidth_ = 0;
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline int32_t ReceiveStatistics::_internal_bandwidth() const {
  return _impl_.bandwidth_;
}
inline int32_t ReceiveStatistics::bandwidth() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.bandwidth)
  return _internal_bandwidth();
}
inline void ReceiveStatistics::_internal_set_bandwidth(int32_t value) {
  _impl_._has_bits_[0] |= 0x02000000u;
  _impl_.bandwidth_ = value;
}
inline void ReceiveStatistics::set_bandwidth(int32_t value) {
  _internal_set_bandwidth(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.bandwidth)
}
 
// optional int32 version = 30 [default = 0, (.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_version() const {
  return _internal_has_version();
}
inline void ReceiveStatistics::clear_version() {
  _impl_.version_ = 0;
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline int32_t ReceiveStatistics::_internal_version() const {
  return _impl_.version_;
}
inline int32_t ReceiveStatistics::version() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.version)
  return _internal_version();
}
inline void ReceiveStatistics::_internal_set_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x04000000u;
  _impl_.version_ = value;
}
inline void ReceiveStatistics::set_version(int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.version)
}
 
// optional string date = 31 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_date() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_date() const {
  return _internal_has_date();
}
inline void ReceiveStatistics::clear_date() {
  _impl_.date_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ReceiveStatistics::date() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
  return _internal_date();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReceiveStatistics::set_date(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.date_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
}
inline std::string* ReceiveStatistics::mutable_date() {
  std::string* _s = _internal_mutable_date();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
  return _s;
}
inline const std::string& ReceiveStatistics::_internal_date() const {
  return _impl_.date_.Get();
}
inline void ReceiveStatistics::_internal_set_date(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.date_.Set(value, GetArenaForAllocation());
}
inline std::string* ReceiveStatistics::_internal_mutable_date() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.date_.Mutable(GetArenaForAllocation());
}
inline std::string* ReceiveStatistics::release_date() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
  if (!_internal_has_date()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.date_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.date_.IsDefault()) {
    _impl_.date_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ReceiveStatistics::set_allocated_date(std::string* date) {
  if (date != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.date_.SetAllocated(date, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.date_.IsDefault()) {
    _impl_.date_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
}
 
// optional int32 pcm = 32 [(.dccl.field) = {
inline bool ReceiveStatistics::_internal_has_pcm() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool ReceiveStatistics::has_pcm() const {
  return _internal_has_pcm();
}
inline void ReceiveStatistics::clear_pcm() {
  _impl_.pcm_ = 0;
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline int32_t ReceiveStatistics::_internal_pcm() const {
  return _impl_.pcm_;
}
inline int32_t ReceiveStatistics::pcm() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.pcm)
  return _internal_pcm();
}
inline void ReceiveStatistics::_internal_set_pcm(int32_t value) {
  _impl_._has_bits_[0] |= 0x08000000u;
  _impl_.pcm_ = value;
}
inline void ReceiveStatistics::set_pcm(int32_t value) {
  _internal_set_pcm(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.pcm)
}
 
// -------------------------------------------------------------------
 
// TransmitStatistics
 
// optional string date = 1;
inline bool TransmitStatistics::_internal_has_date() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TransmitStatistics::has_date() const {
  return _internal_has_date();
}
inline void TransmitStatistics::clear_date() {
  _impl_.date_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TransmitStatistics::date() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
  return _internal_date();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TransmitStatistics::set_date(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.date_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
}
inline std::string* TransmitStatistics::mutable_date() {
  std::string* _s = _internal_mutable_date();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
  return _s;
}
inline const std::string& TransmitStatistics::_internal_date() const {
  return _impl_.date_.Get();
}
inline void TransmitStatistics::_internal_set_date(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.date_.Set(value, GetArenaForAllocation());
}
inline std::string* TransmitStatistics::_internal_mutable_date() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.date_.Mutable(GetArenaForAllocation());
}
inline std::string* TransmitStatistics::release_date() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
  if (!_internal_has_date()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.date_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.date_.IsDefault()) {
    _impl_.date_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void TransmitStatistics::set_allocated_date(std::string* date) {
  if (date != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.date_.SetAllocated(date, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.date_.IsDefault()) {
    _impl_.date_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
}
 
// optional string time = 2;
inline bool TransmitStatistics::_internal_has_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool TransmitStatistics::has_time() const {
  return _internal_has_time();
}
inline void TransmitStatistics::clear_time() {
  _impl_.time_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& TransmitStatistics::time() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
  return _internal_time();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TransmitStatistics::set_time(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.time_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
}
inline std::string* TransmitStatistics::mutable_time() {
  std::string* _s = _internal_mutable_time();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
  return _s;
}
inline const std::string& TransmitStatistics::_internal_time() const {
  return _impl_.time_.Get();
}
inline void TransmitStatistics::_internal_set_time(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.time_.Set(value, GetArenaForAllocation());
}
inline std::string* TransmitStatistics::_internal_mutable_time() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.time_.Mutable(GetArenaForAllocation());
}
inline std::string* TransmitStatistics::release_time() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
  if (!_internal_has_time()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.time_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.time_.IsDefault()) {
    _impl_.time_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void TransmitStatistics::set_allocated_time(std::string* time) {
  if (time != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.time_.SetAllocated(time, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.time_.IsDefault()) {
    _impl_.time_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
}
 
// optional .goby.acomms.micromodem.protobuf.ClockMode clock_mode = 3;
inline bool TransmitStatistics::_internal_has_clock_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool TransmitStatistics::has_clock_mode() const {
  return _internal_has_clock_mode();
}
inline void TransmitStatistics::clear_clock_mode() {
  _impl_.clock_mode_ = -1;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline ::goby::acomms::micromodem::protobuf::ClockMode TransmitStatistics::_internal_clock_mode() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::ClockMode >(_impl_.clock_mode_);
}
inline ::goby::acomms::micromodem::protobuf::ClockMode TransmitStatistics::clock_mode() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.clock_mode)
  return _internal_clock_mode();
}
inline void TransmitStatistics::_internal_set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  assert(::goby::acomms::micromodem::protobuf::ClockMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.clock_mode_ = value;
}
inline void TransmitStatistics::set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  _internal_set_clock_mode(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.clock_mode)
}
 
// optional .goby.acomms.micromodem.protobuf.TransmitMode mode = 4;
inline bool TransmitStatistics::_internal_has_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool TransmitStatistics::has_mode() const {
  return _internal_has_mode();
}
inline void TransmitStatistics::clear_mode() {
  _impl_.mode_ = -1;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline ::goby::acomms::micromodem::protobuf::TransmitMode TransmitStatistics::_internal_mode() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::TransmitMode >(_impl_.mode_);
}
inline ::goby::acomms::micromodem::protobuf::TransmitMode TransmitStatistics::mode() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.mode)
  return _internal_mode();
}
inline void TransmitStatistics::_internal_set_mode(::goby::acomms::micromodem::protobuf::TransmitMode value) {
  assert(::goby::acomms::micromodem::protobuf::TransmitMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.mode_ = value;
}
inline void TransmitStatistics::set_mode(::goby::acomms::micromodem::protobuf::TransmitMode value) {
  _internal_set_mode(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.mode)
}
 
// optional int32 probe_length = 5;
inline bool TransmitStatistics::_internal_has_probe_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool TransmitStatistics::has_probe_length() const {
  return _internal_has_probe_length();
}
inline void TransmitStatistics::clear_probe_length() {
  _impl_.probe_length_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t TransmitStatistics::_internal_probe_length() const {
  return _impl_.probe_length_;
}
inline int32_t TransmitStatistics::probe_length() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.probe_length)
  return _internal_probe_length();
}
inline void TransmitStatistics::_internal_set_probe_length(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.probe_length_ = value;
}
inline void TransmitStatistics::set_probe_length(int32_t value) {
  _internal_set_probe_length(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.probe_length)
}
 
// optional int32 bandwidth = 6;
inline bool TransmitStatistics::_internal_has_bandwidth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool TransmitStatistics::has_bandwidth() const {
  return _internal_has_bandwidth();
}
inline void TransmitStatistics::clear_bandwidth() {
  _impl_.bandwidth_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t TransmitStatistics::_internal_bandwidth() const {
  return _impl_.bandwidth_;
}
inline int32_t TransmitStatistics::bandwidth() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.bandwidth)
  return _internal_bandwidth();
}
inline void TransmitStatistics::_internal_set_bandwidth(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.bandwidth_ = value;
}
inline void TransmitStatistics::set_bandwidth(int32_t value) {
  _internal_set_bandwidth(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.bandwidth)
}
 
// optional int32 carrier_freq = 7;
inline bool TransmitStatistics::_internal_has_carrier_freq() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool TransmitStatistics::has_carrier_freq() const {
  return _internal_has_carrier_freq();
}
inline void TransmitStatistics::clear_carrier_freq() {
  _impl_.carrier_freq_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t TransmitStatistics::_internal_carrier_freq() const {
  return _impl_.carrier_freq_;
}
inline int32_t TransmitStatistics::carrier_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.carrier_freq)
  return _internal_carrier_freq();
}
inline void TransmitStatistics::_internal_set_carrier_freq(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.carrier_freq_ = value;
}
inline void TransmitStatistics::set_carrier_freq(int32_t value) {
  _internal_set_carrier_freq(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.carrier_freq)
}
 
// optional int32 rate = 8;
inline bool TransmitStatistics::_internal_has_rate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool TransmitStatistics::has_rate() const {
  return _internal_has_rate();
}
inline void TransmitStatistics::clear_rate() {
  _impl_.rate_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t TransmitStatistics::_internal_rate() const {
  return _impl_.rate_;
}
inline int32_t TransmitStatistics::rate() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.rate)
  return _internal_rate();
}
inline void TransmitStatistics::_internal_set_rate(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.rate_ = value;
}
inline void TransmitStatistics::set_rate(int32_t value) {
  _internal_set_rate(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.rate)
}
 
// optional int32 source = 9;
inline bool TransmitStatistics::_internal_has_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool TransmitStatistics::has_source() const {
  return _internal_has_source();
}
inline void TransmitStatistics::clear_source() {
  _impl_.source_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t TransmitStatistics::_internal_source() const {
  return _impl_.source_;
}
inline int32_t TransmitStatistics::source() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.source)
  return _internal_source();
}
inline void TransmitStatistics::_internal_set_source(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.source_ = value;
}
inline void TransmitStatistics::set_source(int32_t value) {
  _internal_set_source(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.source)
}
 
// optional int32 dest = 10;
inline bool TransmitStatistics::_internal_has_dest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool TransmitStatistics::has_dest() const {
  return _internal_has_dest();
}
inline void TransmitStatistics::clear_dest() {
  _impl_.dest_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t TransmitStatistics::_internal_dest() const {
  return _impl_.dest_;
}
inline int32_t TransmitStatistics::dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.dest)
  return _internal_dest();
}
inline void TransmitStatistics::_internal_set_dest(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.dest_ = value;
}
inline void TransmitStatistics::set_dest(int32_t value) {
  _internal_set_dest(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.dest)
}
 
// optional bool ack_requested = 11;
inline bool TransmitStatistics::_internal_has_ack_requested() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool TransmitStatistics::has_ack_requested() const {
  return _internal_has_ack_requested();
}
inline void TransmitStatistics::clear_ack_requested() {
  _impl_.ack_requested_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool TransmitStatistics::_internal_ack_requested() const {
  return _impl_.ack_requested_;
}
inline bool TransmitStatistics::ack_requested() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.ack_requested)
  return _internal_ack_requested();
}
inline void TransmitStatistics::_internal_set_ack_requested(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.ack_requested_ = value;
}
inline void TransmitStatistics::set_ack_requested(bool value) {
  _internal_set_ack_requested(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.ack_requested)
}
 
// optional int32 number_frames_expected = 12;
inline bool TransmitStatistics::_internal_has_number_frames_expected() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool TransmitStatistics::has_number_frames_expected() const {
  return _internal_has_number_frames_expected();
}
inline void TransmitStatistics::clear_number_frames_expected() {
  _impl_.number_frames_expected_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t TransmitStatistics::_internal_number_frames_expected() const {
  return _impl_.number_frames_expected_;
}
inline int32_t TransmitStatistics::number_frames_expected() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.number_frames_expected)
  return _internal_number_frames_expected();
}
inline void TransmitStatistics::_internal_set_number_frames_expected(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.number_frames_expected_ = value;
}
inline void TransmitStatistics::set_number_frames_expected(int32_t value) {
  _internal_set_number_frames_expected(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.number_frames_expected)
}
 
// optional int32 number_frames_sent = 13;
inline bool TransmitStatistics::_internal_has_number_frames_sent() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool TransmitStatistics::has_number_frames_sent() const {
  return _internal_has_number_frames_sent();
}
inline void TransmitStatistics::clear_number_frames_sent() {
  _impl_.number_frames_sent_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline int32_t TransmitStatistics::_internal_number_frames_sent() const {
  return _impl_.number_frames_sent_;
}
inline int32_t TransmitStatistics::number_frames_sent() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.number_frames_sent)
  return _internal_number_frames_sent();
}
inline void TransmitStatistics::_internal_set_number_frames_sent(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.number_frames_sent_ = value;
}
inline void TransmitStatistics::set_number_frames_sent(int32_t value) {
  _internal_set_number_frames_sent(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.number_frames_sent)
}
 
// optional .goby.acomms.micromodem.protobuf.PacketType packet_type = 14;
inline bool TransmitStatistics::_internal_has_packet_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool TransmitStatistics::has_packet_type() const {
  return _internal_has_packet_type();
}
inline void TransmitStatistics::clear_packet_type() {
  _impl_.packet_type_ = -1;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline ::goby::acomms::micromodem::protobuf::PacketType TransmitStatistics::_internal_packet_type() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::PacketType >(_impl_.packet_type_);
}
inline ::goby::acomms::micromodem::protobuf::PacketType TransmitStatistics::packet_type() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.packet_type)
  return _internal_packet_type();
}
inline void TransmitStatistics::_internal_set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value) {
  assert(::goby::acomms::micromodem::protobuf::PacketType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.packet_type_ = value;
}
inline void TransmitStatistics::set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value) {
  _internal_set_packet_type(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.packet_type)
}
 
// optional int32 number_bytes = 15;
inline bool TransmitStatistics::_internal_has_number_bytes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool TransmitStatistics::has_number_bytes() const {
  return _internal_has_number_bytes();
}
inline void TransmitStatistics::clear_number_bytes() {
  _impl_.number_bytes_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int32_t TransmitStatistics::_internal_number_bytes() const {
  return _impl_.number_bytes_;
}
inline int32_t TransmitStatistics::number_bytes() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.number_bytes)
  return _internal_number_bytes();
}
inline void TransmitStatistics::_internal_set_number_bytes(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.number_bytes_ = value;
}
inline void TransmitStatistics::set_number_bytes(int32_t value) {
  _internal_set_number_bytes(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.number_bytes)
}
 
// optional int32 version = 100 [default = 0];
inline bool TransmitStatistics::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool TransmitStatistics::has_version() const {
  return _internal_has_version();
}
inline void TransmitStatistics::clear_version() {
  _impl_.version_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int32_t TransmitStatistics::_internal_version() const {
  return _impl_.version_;
}
inline int32_t TransmitStatistics::version() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.version)
  return _internal_version();
}
inline void TransmitStatistics::_internal_set_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.version_ = value;
}
inline void TransmitStatistics::set_version(int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.version)
}
 
// -------------------------------------------------------------------
 
// HardwareControl
 
// required .goby.acomms.micromodem.protobuf.HardwareLine line = 1;
inline bool HardwareControl::_internal_has_line() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool HardwareControl::has_line() const {
  return _internal_has_line();
}
inline void HardwareControl::clear_line() {
  _impl_.line_ = 5;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::goby::acomms::micromodem::protobuf::HardwareLine HardwareControl::_internal_line() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::HardwareLine >(_impl_.line_);
}
inline ::goby::acomms::micromodem::protobuf::HardwareLine HardwareControl::line() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControl.line)
  return _internal_line();
}
inline void HardwareControl::_internal_set_line(::goby::acomms::micromodem::protobuf::HardwareLine value) {
  assert(::goby::acomms::micromodem::protobuf::HardwareLine_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.line_ = value;
}
inline void HardwareControl::set_line(::goby::acomms::micromodem::protobuf::HardwareLine value) {
  _internal_set_line(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.HardwareControl.line)
}
 
// required .goby.acomms.micromodem.protobuf.HardwareControlMode mode = 2;
inline bool HardwareControl::_internal_has_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HardwareControl::has_mode() const {
  return _internal_has_mode();
}
inline void HardwareControl::clear_mode() {
  _impl_.mode_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::goby::acomms::micromodem::protobuf::HardwareControlMode HardwareControl::_internal_mode() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::HardwareControlMode >(_impl_.mode_);
}
inline ::goby::acomms::micromodem::protobuf::HardwareControlMode HardwareControl::mode() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControl.mode)
  return _internal_mode();
}
inline void HardwareControl::_internal_set_mode(::goby::acomms::micromodem::protobuf::HardwareControlMode value) {
  assert(::goby::acomms::micromodem::protobuf::HardwareControlMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.mode_ = value;
}
inline void HardwareControl::set_mode(::goby::acomms::micromodem::protobuf::HardwareControlMode value) {
  _internal_set_mode(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.HardwareControl.mode)
}
 
// optional .goby.acomms.micromodem.protobuf.HardwareControlArgument arg = 3 [default = MODE0_ARG];
inline bool HardwareControl::_internal_has_arg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HardwareControl::has_arg() const {
  return _internal_has_arg();
}
inline void HardwareControl::clear_arg() {
  _impl_.arg_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::goby::acomms::micromodem::protobuf::HardwareControlArgument HardwareControl::_internal_arg() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::HardwareControlArgument >(_impl_.arg_);
}
inline ::goby::acomms::micromodem::protobuf::HardwareControlArgument HardwareControl::arg() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControl.arg)
  return _internal_arg();
}
inline void HardwareControl::_internal_set_arg(::goby::acomms::micromodem::protobuf::HardwareControlArgument value) {
  assert(::goby::acomms::micromodem::protobuf::HardwareControlArgument_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.arg_ = value;
}
inline void HardwareControl::set_arg(::goby::acomms::micromodem::protobuf::HardwareControlArgument value) {
  _internal_set_arg(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.HardwareControl.arg)
}
 
// -------------------------------------------------------------------
 
// HardwareControlCommand
 
// required int32 command_src = 1 [(.dccl.field) = {
inline bool HardwareControlCommand::_internal_has_command_src() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HardwareControlCommand::has_command_src() const {
  return _internal_has_command_src();
}
inline void HardwareControlCommand::clear_command_src() {
  _impl_.command_src_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t HardwareControlCommand::_internal_command_src() const {
  return _impl_.command_src_;
}
inline int32_t HardwareControlCommand::command_src() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControlCommand.command_src)
  return _internal_command_src();
}
inline void HardwareControlCommand::_internal_set_command_src(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.command_src_ = value;
}
inline void HardwareControlCommand::set_command_src(int32_t value) {
  _internal_set_command_src(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.HardwareControlCommand.command_src)
}
 
// required int32 command_dest = 2 [(.dccl.field) = {
inline bool HardwareControlCommand::_internal_has_command_dest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool HardwareControlCommand::has_command_dest() const {
  return _internal_has_command_dest();
}
inline void HardwareControlCommand::clear_command_dest() {
  _impl_.command_dest_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t HardwareControlCommand::_internal_command_dest() const {
  return _impl_.command_dest_;
}
inline int32_t HardwareControlCommand::command_dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControlCommand.command_dest)
  return _internal_command_dest();
}
inline void HardwareControlCommand::_internal_set_command_dest(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.command_dest_ = value;
}
inline void HardwareControlCommand::set_command_dest(int32_t value) {
  _internal_set_command_dest(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.HardwareControlCommand.command_dest)
}
 
// optional uint64 time = 3 [(.dccl.field) = {
inline bool HardwareControlCommand::_internal_has_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool HardwareControlCommand::has_time() const {
  return _internal_has_time();
}
inline void HardwareControlCommand::clear_time() {
  _impl_.time_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t HardwareControlCommand::_internal_time() const {
  return _impl_.time_;
}
inline uint64_t HardwareControlCommand::time() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControlCommand.time)
  return _internal_time();
}
inline void HardwareControlCommand::_internal_set_time(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.time_ = value;
}
inline void HardwareControlCommand::set_time(uint64_t value) {
  _internal_set_time(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.HardwareControlCommand.time)
}
 
// optional int32 hw_ctl_dest = 4 [(.dccl.field) = {
inline bool HardwareControlCommand::_internal_has_hw_ctl_dest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool HardwareControlCommand::has_hw_ctl_dest() const {
  return _internal_has_hw_ctl_dest();
}
inline void HardwareControlCommand::clear_hw_ctl_dest() {
  _impl_.hw_ctl_dest_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t HardwareControlCommand::_internal_hw_ctl_dest() const {
  return _impl_.hw_ctl_dest_;
}
inline int32_t HardwareControlCommand::hw_ctl_dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControlCommand.hw_ctl_dest)
  return _internal_hw_ctl_dest();
}
inline void HardwareControlCommand::_internal_set_hw_ctl_dest(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.hw_ctl_dest_ = value;
}
inline void HardwareControlCommand::set_hw_ctl_dest(int32_t value) {
  _internal_set_hw_ctl_dest(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.HardwareControlCommand.hw_ctl_dest)
}
 
// optional .goby.acomms.micromodem.protobuf.HardwareControl control = 5;
inline bool HardwareControlCommand::_internal_has_control() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.control_ != nullptr);
  return value;
}
inline bool HardwareControlCommand::has_control() const {
  return _internal_has_control();
}
inline void HardwareControlCommand::clear_control() {
  if (_impl_.control_ != nullptr) _impl_.control_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::goby::acomms::micromodem::protobuf::HardwareControl& HardwareControlCommand::_internal_control() const {
  const ::goby::acomms::micromodem::protobuf::HardwareControl* p = _impl_.control_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::HardwareControl&>(
      ::goby::acomms::micromodem::protobuf::_HardwareControl_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::HardwareControl& HardwareControlCommand::control() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControlCommand.control)
  return _internal_control();
}
inline void HardwareControlCommand::unsafe_arena_set_allocated_control(
    ::goby::acomms::micromodem::protobuf::HardwareControl* control) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.control_);
  }
  _impl_.control_ = control;
  if (control) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.HardwareControlCommand.control)
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* HardwareControlCommand::release_control() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::micromodem::protobuf::HardwareControl* temp = _impl_.control_;
  _impl_.control_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* HardwareControlCommand::unsafe_arena_release_control() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.HardwareControlCommand.control)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::micromodem::protobuf::HardwareControl* temp = _impl_.control_;
  _impl_.control_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* HardwareControlCommand::_internal_mutable_control() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.control_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::HardwareControl>(GetArenaForAllocation());
    _impl_.control_ = p;
  }
  return _impl_.control_;
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* HardwareControlCommand::mutable_control() {
  ::goby::acomms::micromodem::protobuf::HardwareControl* _msg = _internal_mutable_control();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.HardwareControlCommand.control)
  return _msg;
}
inline void HardwareControlCommand::set_allocated_control(::goby::acomms::micromodem::protobuf::HardwareControl* control) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.control_;
  }
  if (control) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(control);
    if (message_arena != submessage_arena) {
      control = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, control, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.control_ = control;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.HardwareControlCommand.control)
}
 
// -------------------------------------------------------------------
 
// Transmission
 
// optional .goby.acomms.micromodem.protobuf.TransmissionType type = 1 [default = BASE_TYPE, (.goby.field) = {
inline bool Transmission::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Transmission::has_type() const {
  return _internal_has_type();
}
inline void Transmission::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline ::goby::acomms::micromodem::protobuf::TransmissionType Transmission::_internal_type() const {
  return static_cast< ::goby::acomms::micromodem::protobuf::TransmissionType >(_impl_.type_);
}
inline ::goby::acomms::micromodem::protobuf::TransmissionType Transmission::type() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.type)
  return _internal_type();
}
inline void Transmission::_internal_set_type(::goby::acomms::micromodem::protobuf::TransmissionType value) {
  assert(::goby::acomms::micromodem::protobuf::TransmissionType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.type_ = value;
}
inline void Transmission::set_type(::goby::acomms::micromodem::protobuf::TransmissionType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Transmission.type)
}
 
// optional .goby.acomms.micromodem.protobuf.NarrowBandLBLParams narrowband_lbl = 2 [(.dccl.field) = {
inline bool Transmission::_internal_has_narrowband_lbl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.narrowband_lbl_ != nullptr);
  return value;
}
inline bool Transmission::has_narrowband_lbl() const {
  return _internal_has_narrowband_lbl();
}
inline void Transmission::clear_narrowband_lbl() {
  if (_impl_.narrowband_lbl_ != nullptr) _impl_.narrowband_lbl_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& Transmission::_internal_narrowband_lbl() const {
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* p = _impl_.narrowband_lbl_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams&>(
      ::goby::acomms::micromodem::protobuf::_NarrowBandLBLParams_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& Transmission::narrowband_lbl() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.narrowband_lbl)
  return _internal_narrowband_lbl();
}
inline void Transmission::unsafe_arena_set_allocated_narrowband_lbl(
    ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.narrowband_lbl_);
  }
  _impl_.narrowband_lbl_ = narrowband_lbl;
  if (narrowband_lbl) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Transmission.narrowband_lbl)
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Transmission::release_narrowband_lbl() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* temp = _impl_.narrowband_lbl_;
  _impl_.narrowband_lbl_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Transmission::unsafe_arena_release_narrowband_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.narrowband_lbl)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* temp = _impl_.narrowband_lbl_;
  _impl_.narrowband_lbl_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Transmission::_internal_mutable_narrowband_lbl() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.narrowband_lbl_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::NarrowBandLBLParams>(GetArenaForAllocation());
    _impl_.narrowband_lbl_ = p;
  }
  return _impl_.narrowband_lbl_;
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Transmission::mutable_narrowband_lbl() {
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* _msg = _internal_mutable_narrowband_lbl();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.narrowband_lbl)
  return _msg;
}
inline void Transmission::set_allocated_narrowband_lbl(::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.narrowband_lbl_;
  }
  if (narrowband_lbl) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(narrowband_lbl);
    if (message_arena != submessage_arena) {
      narrowband_lbl = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, narrowband_lbl, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.narrowband_lbl_ = narrowband_lbl;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Transmission.narrowband_lbl)
}
 
// optional .goby.acomms.micromodem.protobuf.REMUSLBLParams remus_lbl = 3 [(.dccl.field) = {
inline bool Transmission::_internal_has_remus_lbl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.remus_lbl_ != nullptr);
  return value;
}
inline bool Transmission::has_remus_lbl() const {
  return _internal_has_remus_lbl();
}
inline void Transmission::clear_remus_lbl() {
  if (_impl_.remus_lbl_ != nullptr) _impl_.remus_lbl_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& Transmission::_internal_remus_lbl() const {
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams* p = _impl_.remus_lbl_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::REMUSLBLParams&>(
      ::goby::acomms::micromodem::protobuf::_REMUSLBLParams_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& Transmission::remus_lbl() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.remus_lbl)
  return _internal_remus_lbl();
}
inline void Transmission::unsafe_arena_set_allocated_remus_lbl(
    ::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.remus_lbl_);
  }
  _impl_.remus_lbl_ = remus_lbl;
  if (remus_lbl) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Transmission.remus_lbl)
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Transmission::release_remus_lbl() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* temp = _impl_.remus_lbl_;
  _impl_.remus_lbl_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Transmission::unsafe_arena_release_remus_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.remus_lbl)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* temp = _impl_.remus_lbl_;
  _impl_.remus_lbl_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Transmission::_internal_mutable_remus_lbl() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.remus_lbl_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::REMUSLBLParams>(GetArenaForAllocation());
    _impl_.remus_lbl_ = p;
  }
  return _impl_.remus_lbl_;
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Transmission::mutable_remus_lbl() {
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* _msg = _internal_mutable_remus_lbl();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.remus_lbl)
  return _msg;
}
inline void Transmission::set_allocated_remus_lbl(::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.remus_lbl_;
  }
  if (remus_lbl) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(remus_lbl);
    if (message_arena != submessage_arena) {
      remus_lbl = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, remus_lbl, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.remus_lbl_ = remus_lbl;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Transmission.remus_lbl)
}
 
// optional .goby.acomms.micromodem.protobuf.RangingReply ranging_reply = 4 [(.goby.field) = {
inline bool Transmission::_internal_has_ranging_reply() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ranging_reply_ != nullptr);
  return value;
}
inline bool Transmission::has_ranging_reply() const {
  return _internal_has_ranging_reply();
}
inline void Transmission::clear_ranging_reply() {
  if (_impl_.ranging_reply_ != nullptr) _impl_.ranging_reply_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::goby::acomms::micromodem::protobuf::RangingReply& Transmission::_internal_ranging_reply() const {
  const ::goby::acomms::micromodem::protobuf::RangingReply* p = _impl_.ranging_reply_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::RangingReply&>(
      ::goby::acomms::micromodem::protobuf::_RangingReply_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::RangingReply& Transmission::ranging_reply() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.ranging_reply)
  return _internal_ranging_reply();
}
inline void Transmission::unsafe_arena_set_allocated_ranging_reply(
    ::goby::acomms::micromodem::protobuf::RangingReply* ranging_reply) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ranging_reply_);
  }
  _impl_.ranging_reply_ = ranging_reply;
  if (ranging_reply) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Transmission.ranging_reply)
}
inline ::goby::acomms::micromodem::protobuf::RangingReply* Transmission::release_ranging_reply() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::goby::acomms::micromodem::protobuf::RangingReply* temp = _impl_.ranging_reply_;
  _impl_.ranging_reply_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::RangingReply* Transmission::unsafe_arena_release_ranging_reply() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.ranging_reply)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::goby::acomms::micromodem::protobuf::RangingReply* temp = _impl_.ranging_reply_;
  _impl_.ranging_reply_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::RangingReply* Transmission::_internal_mutable_ranging_reply() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.ranging_reply_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::RangingReply>(GetArenaForAllocation());
    _impl_.ranging_reply_ = p;
  }
  return _impl_.ranging_reply_;
}
inline ::goby::acomms::micromodem::protobuf::RangingReply* Transmission::mutable_ranging_reply() {
  ::goby::acomms::micromodem::protobuf::RangingReply* _msg = _internal_mutable_ranging_reply();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.ranging_reply)
  return _msg;
}
inline void Transmission::set_allocated_ranging_reply(::goby::acomms::micromodem::protobuf::RangingReply* ranging_reply) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.ranging_reply_;
  }
  if (ranging_reply) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ranging_reply);
    if (message_arena != submessage_arena) {
      ranging_reply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ranging_reply, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.ranging_reply_ = ranging_reply;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Transmission.ranging_reply)
}
 
// repeated .goby.acomms.micromodem.protobuf.ReceiveStatistics receive_stat = 5 [(.goby.field) = {
inline int Transmission::_internal_receive_stat_size() const {
  return _impl_.receive_stat_.size();
}
inline int Transmission::receive_stat_size() const {
  return _internal_receive_stat_size();
}
inline void Transmission::clear_receive_stat() {
  _impl_.receive_stat_.Clear();
}
inline ::goby::acomms::micromodem::protobuf::ReceiveStatistics* Transmission::mutable_receive_stat(int index) {
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.receive_stat)
  return _impl_.receive_stat_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::ReceiveStatistics >*
Transmission::mutable_receive_stat() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.Transmission.receive_stat)
  return &_impl_.receive_stat_;
}
inline const ::goby::acomms::micromodem::protobuf::ReceiveStatistics& Transmission::_internal_receive_stat(int index) const {
  return _impl_.receive_stat_.Get(index);
}
inline const ::goby::acomms::micromodem::protobuf::ReceiveStatistics& Transmission::receive_stat(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.receive_stat)
  return _internal_receive_stat(index);
}
inline ::goby::acomms::micromodem::protobuf::ReceiveStatistics* Transmission::_internal_add_receive_stat() {
  return _impl_.receive_stat_.Add();
}
inline ::goby::acomms::micromodem::protobuf::ReceiveStatistics* Transmission::add_receive_stat() {
  ::goby::acomms::micromodem::protobuf::ReceiveStatistics* _add = _internal_add_receive_stat();
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Transmission.receive_stat)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::ReceiveStatistics >&
Transmission::receive_stat() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.Transmission.receive_stat)
  return _impl_.receive_stat_;
}
 
// repeated .goby.acomms.micromodem.protobuf.TransmitStatistics transmit_stat = 6 [(.goby.field) = {
inline int Transmission::_internal_transmit_stat_size() const {
  return _impl_.transmit_stat_.size();
}
inline int Transmission::transmit_stat_size() const {
  return _internal_transmit_stat_size();
}
inline void Transmission::clear_transmit_stat() {
  _impl_.transmit_stat_.Clear();
}
inline ::goby::acomms::micromodem::protobuf::TransmitStatistics* Transmission::mutable_transmit_stat(int index) {
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.transmit_stat)
  return _impl_.transmit_stat_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::TransmitStatistics >*
Transmission::mutable_transmit_stat() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.Transmission.transmit_stat)
  return &_impl_.transmit_stat_;
}
inline const ::goby::acomms::micromodem::protobuf::TransmitStatistics& Transmission::_internal_transmit_stat(int index) const {
  return _impl_.transmit_stat_.Get(index);
}
inline const ::goby::acomms::micromodem::protobuf::TransmitStatistics& Transmission::transmit_stat(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.transmit_stat)
  return _internal_transmit_stat(index);
}
inline ::goby::acomms::micromodem::protobuf::TransmitStatistics* Transmission::_internal_add_transmit_stat() {
  return _impl_.transmit_stat_.Add();
}
inline ::goby::acomms::micromodem::protobuf::TransmitStatistics* Transmission::add_transmit_stat() {
  ::goby::acomms::micromodem::protobuf::TransmitStatistics* _add = _internal_add_transmit_stat();
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Transmission.transmit_stat)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::TransmitStatistics >&
Transmission::transmit_stat() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.Transmission.transmit_stat)
  return _impl_.transmit_stat_;
}
 
// repeated int32 frame_with_bad_crc = 7 [(.goby.field) = {
inline int Transmission::_internal_frame_with_bad_crc_size() const {
  return _impl_.frame_with_bad_crc_.size();
}
inline int Transmission::frame_with_bad_crc_size() const {
  return _internal_frame_with_bad_crc_size();
}
inline void Transmission::clear_frame_with_bad_crc() {
  _impl_.frame_with_bad_crc_.Clear();
}
inline int32_t Transmission::_internal_frame_with_bad_crc(int index) const {
  return _impl_.frame_with_bad_crc_.Get(index);
}
inline int32_t Transmission::frame_with_bad_crc(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.frame_with_bad_crc)
  return _internal_frame_with_bad_crc(index);
}
inline void Transmission::set_frame_with_bad_crc(int index, int32_t value) {
  _impl_.frame_with_bad_crc_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Transmission.frame_with_bad_crc)
}
inline void Transmission::_internal_add_frame_with_bad_crc(int32_t value) {
  _impl_.frame_with_bad_crc_.Add(value);
}
inline void Transmission::add_frame_with_bad_crc(int32_t value) {
  _internal_add_frame_with_bad_crc(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Transmission.frame_with_bad_crc)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Transmission::_internal_frame_with_bad_crc() const {
  return _impl_.frame_with_bad_crc_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Transmission::frame_with_bad_crc() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.Transmission.frame_with_bad_crc)
  return _internal_frame_with_bad_crc();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Transmission::_internal_mutable_frame_with_bad_crc() {
  return &_impl_.frame_with_bad_crc_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Transmission::mutable_frame_with_bad_crc() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.Transmission.frame_with_bad_crc)
  return _internal_mutable_frame_with_bad_crc();
}
 
// optional .goby.acomms.micromodem.protobuf.HardwareControl hw_ctl = 8 [(.dccl.field) = {
inline bool Transmission::_internal_has_hw_ctl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hw_ctl_ != nullptr);
  return value;
}
inline bool Transmission::has_hw_ctl() const {
  return _internal_has_hw_ctl();
}
inline void Transmission::clear_hw_ctl() {
  if (_impl_.hw_ctl_ != nullptr) _impl_.hw_ctl_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::goby::acomms::micromodem::protobuf::HardwareControl& Transmission::_internal_hw_ctl() const {
  const ::goby::acomms::micromodem::protobuf::HardwareControl* p = _impl_.hw_ctl_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::HardwareControl&>(
      ::goby::acomms::micromodem::protobuf::_HardwareControl_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::HardwareControl& Transmission::hw_ctl() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.hw_ctl)
  return _internal_hw_ctl();
}
inline void Transmission::unsafe_arena_set_allocated_hw_ctl(
    ::goby::acomms::micromodem::protobuf::HardwareControl* hw_ctl) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hw_ctl_);
  }
  _impl_.hw_ctl_ = hw_ctl;
  if (hw_ctl) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Transmission.hw_ctl)
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* Transmission::release_hw_ctl() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::goby::acomms::micromodem::protobuf::HardwareControl* temp = _impl_.hw_ctl_;
  _impl_.hw_ctl_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* Transmission::unsafe_arena_release_hw_ctl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.hw_ctl)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::goby::acomms::micromodem::protobuf::HardwareControl* temp = _impl_.hw_ctl_;
  _impl_.hw_ctl_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* Transmission::_internal_mutable_hw_ctl() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.hw_ctl_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::HardwareControl>(GetArenaForAllocation());
    _impl_.hw_ctl_ = p;
  }
  return _impl_.hw_ctl_;
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* Transmission::mutable_hw_ctl() {
  ::goby::acomms::micromodem::protobuf::HardwareControl* _msg = _internal_mutable_hw_ctl();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.hw_ctl)
  return _msg;
}
inline void Transmission::set_allocated_hw_ctl(::goby::acomms::micromodem::protobuf::HardwareControl* hw_ctl) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hw_ctl_;
  }
  if (hw_ctl) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hw_ctl);
    if (message_arena != submessage_arena) {
      hw_ctl = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hw_ctl, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.hw_ctl_ = hw_ctl;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Transmission.hw_ctl)
}
 
// optional .goby.acomms.micromodem.protobuf.GenericLBLParams generic_lbl = 9 [(.dccl.field) = {
inline bool Transmission::_internal_has_generic_lbl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.generic_lbl_ != nullptr);
  return value;
}
inline bool Transmission::has_generic_lbl() const {
  return _internal_has_generic_lbl();
}
inline void Transmission::clear_generic_lbl() {
  if (_impl_.generic_lbl_ != nullptr) _impl_.generic_lbl_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::goby::acomms::micromodem::protobuf::GenericLBLParams& Transmission::_internal_generic_lbl() const {
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams* p = _impl_.generic_lbl_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::GenericLBLParams&>(
      ::goby::acomms::micromodem::protobuf::_GenericLBLParams_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::GenericLBLParams& Transmission::generic_lbl() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.generic_lbl)
  return _internal_generic_lbl();
}
inline void Transmission::unsafe_arena_set_allocated_generic_lbl(
    ::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.generic_lbl_);
  }
  _impl_.generic_lbl_ = generic_lbl;
  if (generic_lbl) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Transmission.generic_lbl)
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Transmission::release_generic_lbl() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* temp = _impl_.generic_lbl_;
  _impl_.generic_lbl_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Transmission::unsafe_arena_release_generic_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.generic_lbl)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* temp = _impl_.generic_lbl_;
  _impl_.generic_lbl_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Transmission::_internal_mutable_generic_lbl() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.generic_lbl_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::GenericLBLParams>(GetArenaForAllocation());
    _impl_.generic_lbl_ = p;
  }
  return _impl_.generic_lbl_;
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Transmission::mutable_generic_lbl() {
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* _msg = _internal_mutable_generic_lbl();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.generic_lbl)
  return _msg;
}
inline void Transmission::set_allocated_generic_lbl(::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.generic_lbl_;
  }
  if (generic_lbl) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(generic_lbl);
    if (message_arena != submessage_arena) {
      generic_lbl = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, generic_lbl, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.generic_lbl_ = generic_lbl;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Transmission.generic_lbl)
}
 
// optional .goby.acomms.micromodem.protobuf.FMSweepParams fm_sweep = 10 [(.dccl.field) = {
inline bool Transmission::_internal_has_fm_sweep() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fm_sweep_ != nullptr);
  return value;
}
inline bool Transmission::has_fm_sweep() const {
  return _internal_has_fm_sweep();
}
inline void Transmission::clear_fm_sweep() {
  if (_impl_.fm_sweep_ != nullptr) _impl_.fm_sweep_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::goby::acomms::micromodem::protobuf::FMSweepParams& Transmission::_internal_fm_sweep() const {
  const ::goby::acomms::micromodem::protobuf::FMSweepParams* p = _impl_.fm_sweep_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::FMSweepParams&>(
      ::goby::acomms::micromodem::protobuf::_FMSweepParams_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::FMSweepParams& Transmission::fm_sweep() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.fm_sweep)
  return _internal_fm_sweep();
}
inline void Transmission::unsafe_arena_set_allocated_fm_sweep(
    ::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fm_sweep_);
  }
  _impl_.fm_sweep_ = fm_sweep;
  if (fm_sweep) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Transmission.fm_sweep)
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Transmission::release_fm_sweep() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::goby::acomms::micromodem::protobuf::FMSweepParams* temp = _impl_.fm_sweep_;
  _impl_.fm_sweep_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Transmission::unsafe_arena_release_fm_sweep() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.fm_sweep)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::goby::acomms::micromodem::protobuf::FMSweepParams* temp = _impl_.fm_sweep_;
  _impl_.fm_sweep_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Transmission::_internal_mutable_fm_sweep() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.fm_sweep_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::FMSweepParams>(GetArenaForAllocation());
    _impl_.fm_sweep_ = p;
  }
  return _impl_.fm_sweep_;
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Transmission::mutable_fm_sweep() {
  ::goby::acomms::micromodem::protobuf::FMSweepParams* _msg = _internal_mutable_fm_sweep();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.fm_sweep)
  return _msg;
}
inline void Transmission::set_allocated_fm_sweep(::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.fm_sweep_;
  }
  if (fm_sweep) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fm_sweep);
    if (message_arena != submessage_arena) {
      fm_sweep = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fm_sweep, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.fm_sweep_ = fm_sweep;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Transmission.fm_sweep)
}
 
// optional .goby.acomms.micromodem.protobuf.MSequenceParams m_sequence = 11 [(.dccl.field) = {
inline bool Transmission::_internal_has_m_sequence() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.m_sequence_ != nullptr);
  return value;
}
inline bool Transmission::has_m_sequence() const {
  return _internal_has_m_sequence();
}
inline void Transmission::clear_m_sequence() {
  if (_impl_.m_sequence_ != nullptr) _impl_.m_sequence_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::goby::acomms::micromodem::protobuf::MSequenceParams& Transmission::_internal_m_sequence() const {
  const ::goby::acomms::micromodem::protobuf::MSequenceParams* p = _impl_.m_sequence_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::micromodem::protobuf::MSequenceParams&>(
      ::goby::acomms::micromodem::protobuf::_MSequenceParams_default_instance_);
}
inline const ::goby::acomms::micromodem::protobuf::MSequenceParams& Transmission::m_sequence() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.m_sequence)
  return _internal_m_sequence();
}
inline void Transmission::unsafe_arena_set_allocated_m_sequence(
    ::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.m_sequence_);
  }
  _impl_.m_sequence_ = m_sequence;
  if (m_sequence) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.micromodem.protobuf.Transmission.m_sequence)
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Transmission::release_m_sequence() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::goby::acomms::micromodem::protobuf::MSequenceParams* temp = _impl_.m_sequence_;
  _impl_.m_sequence_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Transmission::unsafe_arena_release_m_sequence() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.m_sequence)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::goby::acomms::micromodem::protobuf::MSequenceParams* temp = _impl_.m_sequence_;
  _impl_.m_sequence_ = nullptr;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Transmission::_internal_mutable_m_sequence() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.m_sequence_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::MSequenceParams>(GetArenaForAllocation());
    _impl_.m_sequence_ = p;
  }
  return _impl_.m_sequence_;
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Transmission::mutable_m_sequence() {
  ::goby::acomms::micromodem::protobuf::MSequenceParams* _msg = _internal_mutable_m_sequence();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.m_sequence)
  return _msg;
}
inline void Transmission::set_allocated_m_sequence(::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.m_sequence_;
  }
  if (m_sequence) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(m_sequence);
    if (message_arena != submessage_arena) {
      m_sequence = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, m_sequence, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.m_sequence_ = m_sequence;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.Transmission.m_sequence)
}
 
// -------------------------------------------------------------------
 
// MMApplicationAck_AckPart
 
// required int32 ack_dest = 1 [(.dccl.field) = {
inline bool MMApplicationAck_AckPart::_internal_has_ack_dest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MMApplicationAck_AckPart::has_ack_dest() const {
  return _internal_has_ack_dest();
}
inline void MMApplicationAck_AckPart::clear_ack_dest() {
  _impl_.ack_dest_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t MMApplicationAck_AckPart::_internal_ack_dest() const {
  return _impl_.ack_dest_;
}
inline int32_t MMApplicationAck_AckPart::ack_dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart.ack_dest)
  return _internal_ack_dest();
}
inline void MMApplicationAck_AckPart::_internal_set_ack_dest(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ack_dest_ = value;
}
inline void MMApplicationAck_AckPart::set_ack_dest(int32_t value) {
  _internal_set_ack_dest(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart.ack_dest)
}
 
// required uint32 acked_frames = 2 [(.dccl.field) = {
inline bool MMApplicationAck_AckPart::_internal_has_acked_frames() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MMApplicationAck_AckPart::has_acked_frames() const {
  return _internal_has_acked_frames();
}
inline void MMApplicationAck_AckPart::clear_acked_frames() {
  _impl_.acked_frames_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t MMApplicationAck_AckPart::_internal_acked_frames() const {
  return _impl_.acked_frames_;
}
inline uint32_t MMApplicationAck_AckPart::acked_frames() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart.acked_frames)
  return _internal_acked_frames();
}
inline void MMApplicationAck_AckPart::_internal_set_acked_frames(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.acked_frames_ = value;
}
inline void MMApplicationAck_AckPart::set_acked_frames(uint32_t value) {
  _internal_set_acked_frames(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart.acked_frames)
}
 
// -------------------------------------------------------------------
 
// MMApplicationAck
 
// repeated .goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart part = 1 [(.dccl.field) = {
inline int MMApplicationAck::_internal_part_size() const {
  return _impl_.part_.size();
}
inline int MMApplicationAck::part_size() const {
  return _internal_part_size();
}
inline void MMApplicationAck::clear_part() {
  _impl_.part_.Clear();
}
inline ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart* MMApplicationAck::mutable_part(int index) {
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.MMApplicationAck.part)
  return _impl_.part_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart >*
MMApplicationAck::mutable_part() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.MMApplicationAck.part)
  return &_impl_.part_;
}
inline const ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart& MMApplicationAck::_internal_part(int index) const {
  return _impl_.part_.Get(index);
}
inline const ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart& MMApplicationAck::part(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MMApplicationAck.part)
  return _internal_part(index);
}
inline ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart* MMApplicationAck::_internal_add_part() {
  return _impl_.part_.Add();
}
inline ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart* MMApplicationAck::add_part() {
  ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart* _add = _internal_add_part();
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.MMApplicationAck.part)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart >&
MMApplicationAck::part() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.MMApplicationAck.part)
  return _impl_.part_;
}
 
// required bool ack_requested = 3;
inline bool MMApplicationAck::_internal_has_ack_requested() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MMApplicationAck::has_ack_requested() const {
  return _internal_has_ack_requested();
}
inline void MMApplicationAck::clear_ack_requested() {
  _impl_.ack_requested_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool MMApplicationAck::_internal_ack_requested() const {
  return _impl_.ack_requested_;
}
inline bool MMApplicationAck::ack_requested() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MMApplicationAck.ack_requested)
  return _internal_ack_requested();
}
inline void MMApplicationAck::_internal_set_ack_requested(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ack_requested_ = value;
}
inline void MMApplicationAck::set_ack_requested(bool value) {
  _internal_set_ack_requested(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.MMApplicationAck.ack_requested)
}
 
// required uint32 frame_start = 4 [(.dccl.field) = {
inline bool MMApplicationAck::_internal_has_frame_start() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MMApplicationAck::has_frame_start() const {
  return _internal_has_frame_start();
}
inline void MMApplicationAck::clear_frame_start() {
  _impl_.frame_start_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t MMApplicationAck::_internal_frame_start() const {
  return _impl_.frame_start_;
}
inline uint32_t MMApplicationAck::frame_start() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MMApplicationAck.frame_start)
  return _internal_frame_start();
}
inline void MMApplicationAck::_internal_set_frame_start(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.frame_start_ = value;
}
inline void MMApplicationAck::set_frame_start(uint32_t value) {
  _internal_set_frame_start(value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.MMApplicationAck.frame_start)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protobuf
}  // namespace micromodem
}  // namespace acomms
}  // namespace goby
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity>() {
  return ::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::micromodem::protobuf::ClockMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::micromodem::protobuf::ClockMode>() {
  return ::goby::acomms::micromodem::protobuf::ClockMode_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::micromodem::protobuf::PacketType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::micromodem::protobuf::PacketType>() {
  return ::goby::acomms::micromodem::protobuf::PacketType_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::micromodem::protobuf::ReceiveMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::micromodem::protobuf::ReceiveMode>() {
  return ::goby::acomms::micromodem::protobuf::ReceiveMode_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::micromodem::protobuf::PSKErrorCode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::micromodem::protobuf::PSKErrorCode>() {
  return ::goby::acomms::micromodem::protobuf::PSKErrorCode_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::micromodem::protobuf::TransmitMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::micromodem::protobuf::TransmitMode>() {
  return ::goby::acomms::micromodem::protobuf::TransmitMode_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::micromodem::protobuf::TransmissionType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::micromodem::protobuf::TransmissionType>() {
  return ::goby::acomms::micromodem::protobuf::TransmissionType_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::micromodem::protobuf::HardwareLine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::micromodem::protobuf::HardwareLine>() {
  return ::goby::acomms::micromodem::protobuf::HardwareLine_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::micromodem::protobuf::HardwareControlMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::micromodem::protobuf::HardwareControlMode>() {
  return ::goby::acomms::micromodem::protobuf::HardwareControlMode_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::micromodem::protobuf::HardwareControlArgument> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::micromodem::protobuf::HardwareControlArgument>() {
  return ::goby::acomms::micromodem::protobuf::HardwareControlArgument_descriptor();
}
 
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
 
#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto