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 PROTOBUF_INCLUDED_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto
#define PROTOBUF_INCLUDED_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto
 
#include <string>
 
#include <google/protobuf/stubs/common.h>
 
#if GOOGLE_PROTOBUF_VERSION < 3006001
#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 3006001 < GOOGLE_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/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.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)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto 
 
namespace protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[15];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto
namespace goby {
namespace acomms {
namespace micromodem {
namespace protobuf {
class Config;
class ConfigDefaultTypeInternal;
extern ConfigDefaultTypeInternal _Config_default_instance_;
class Config_Revision;
class Config_RevisionDefaultTypeInternal;
extern Config_RevisionDefaultTypeInternal _Config_Revision_default_instance_;
class FMSweepParams;
class FMSweepParamsDefaultTypeInternal;
extern FMSweepParamsDefaultTypeInternal _FMSweepParams_default_instance_;
class GenericLBLParams;
class GenericLBLParamsDefaultTypeInternal;
extern GenericLBLParamsDefaultTypeInternal _GenericLBLParams_default_instance_;
class HardwareControl;
class HardwareControlDefaultTypeInternal;
extern HardwareControlDefaultTypeInternal _HardwareControl_default_instance_;
class HardwareControlCommand;
class HardwareControlCommandDefaultTypeInternal;
extern HardwareControlCommandDefaultTypeInternal _HardwareControlCommand_default_instance_;
class MMApplicationAck;
class MMApplicationAckDefaultTypeInternal;
extern MMApplicationAckDefaultTypeInternal _MMApplicationAck_default_instance_;
class MMApplicationAck_AckPart;
class MMApplicationAck_AckPartDefaultTypeInternal;
extern MMApplicationAck_AckPartDefaultTypeInternal _MMApplicationAck_AckPart_default_instance_;
class MSequenceParams;
class MSequenceParamsDefaultTypeInternal;
extern MSequenceParamsDefaultTypeInternal _MSequenceParams_default_instance_;
class NarrowBandLBLParams;
class NarrowBandLBLParamsDefaultTypeInternal;
extern NarrowBandLBLParamsDefaultTypeInternal _NarrowBandLBLParams_default_instance_;
class REMUSLBLParams;
class REMUSLBLParamsDefaultTypeInternal;
extern REMUSLBLParamsDefaultTypeInternal _REMUSLBLParams_default_instance_;
class RangingReply;
class RangingReplyDefaultTypeInternal;
extern RangingReplyDefaultTypeInternal _RangingReply_default_instance_;
class ReceiveStatistics;
class ReceiveStatisticsDefaultTypeInternal;
extern ReceiveStatisticsDefaultTypeInternal _ReceiveStatistics_default_instance_;
class Transmission;
class TransmissionDefaultTypeInternal;
extern TransmissionDefaultTypeInternal _Transmission_default_instance_;
class TransmitStatistics;
class TransmitStatisticsDefaultTypeInternal;
extern TransmitStatisticsDefaultTypeInternal _TransmitStatistics_default_instance_;
}  // namespace protobuf
}  // namespace micromodem
}  // namespace acomms
}  // namespace goby
namespace google {
namespace protobuf {
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*);
}  // namespace protobuf
}  // namespace google
namespace goby {
namespace acomms {
namespace micromodem {
namespace protobuf {
 
enum RangingReply_OWTTAmbiguity {
  RangingReply_OWTTAmbiguity_OWTT_EXACT = 1,
  RangingReply_OWTTAmbiguity_OWTT_SECOND_AMBIGUOUS = 2
};
bool RangingReply_OWTTAmbiguity_IsValid(int value);
const RangingReply_OWTTAmbiguity RangingReply_OWTTAmbiguity_OWTTAmbiguity_MIN = RangingReply_OWTTAmbiguity_OWTT_EXACT;
const RangingReply_OWTTAmbiguity RangingReply_OWTTAmbiguity_OWTTAmbiguity_MAX = RangingReply_OWTTAmbiguity_OWTT_SECOND_AMBIGUOUS;
const int RangingReply_OWTTAmbiguity_OWTTAmbiguity_ARRAYSIZE = RangingReply_OWTTAmbiguity_OWTTAmbiguity_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* RangingReply_OWTTAmbiguity_descriptor();
inline const ::std::string& RangingReply_OWTTAmbiguity_Name(RangingReply_OWTTAmbiguity value) {
  return ::google::protobuf::internal::NameOfEnum(
    RangingReply_OWTTAmbiguity_descriptor(), value);
}
inline bool RangingReply_OWTTAmbiguity_Parse(
    const ::std::string& name, RangingReply_OWTTAmbiguity* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RangingReply_OWTTAmbiguity>(
    RangingReply_OWTTAmbiguity_descriptor(), name, value);
}
enum ClockMode {
  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);
const ClockMode ClockMode_MIN = INVALID_CLOCK_MODE;
const ClockMode ClockMode_MAX = SYNC_TO_PPS_AND_CCCLK_GOOD;
const int ClockMode_ARRAYSIZE = ClockMode_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* ClockMode_descriptor();
inline const ::std::string& ClockMode_Name(ClockMode value) {
  return ::google::protobuf::internal::NameOfEnum(
    ClockMode_descriptor(), value);
}
inline bool ClockMode_Parse(
    const ::std::string& name, ClockMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ClockMode>(
    ClockMode_descriptor(), name, value);
}
enum PacketType {
  PACKET_TYPE_UNKNOWN = -1,
  FSK = 1,
  FSK_MINI = 2,
  PSK = 3,
  PSK_MINI = 4,
  FLEXIBLE_DATA_PACKET = 5
};
bool PacketType_IsValid(int value);
const PacketType PacketType_MIN = PACKET_TYPE_UNKNOWN;
const PacketType PacketType_MAX = FLEXIBLE_DATA_PACKET;
const int PacketType_ARRAYSIZE = PacketType_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* PacketType_descriptor();
inline const ::std::string& PacketType_Name(PacketType value) {
  return ::google::protobuf::internal::NameOfEnum(
    PacketType_descriptor(), value);
}
inline bool PacketType_Parse(
    const ::std::string& name, PacketType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<PacketType>(
    PacketType_descriptor(), name, value);
}
enum ReceiveMode {
  INVALID_RECEIVE_MODE = -1,
  RECEIVE_GOOD = 0,
  BAD_CRC = 1,
  PACKET_TIMEOUT = 2
};
bool ReceiveMode_IsValid(int value);
const ReceiveMode ReceiveMode_MIN = INVALID_RECEIVE_MODE;
const ReceiveMode ReceiveMode_MAX = PACKET_TIMEOUT;
const int ReceiveMode_ARRAYSIZE = ReceiveMode_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* ReceiveMode_descriptor();
inline const ::std::string& ReceiveMode_Name(ReceiveMode value) {
  return ::google::protobuf::internal::NameOfEnum(
    ReceiveMode_descriptor(), value);
}
inline bool ReceiveMode_Parse(
    const ::std::string& name, ReceiveMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ReceiveMode>(
    ReceiveMode_descriptor(), name, value);
}
enum PSKErrorCode {
  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);
const PSKErrorCode PSKErrorCode_MIN = INVALID_PSK_ERROR_CODE;
const PSKErrorCode PSKErrorCode_MAX = MISSED_START_OF_PSK_PACKET;
const int PSKErrorCode_ARRAYSIZE = PSKErrorCode_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* PSKErrorCode_descriptor();
inline const ::std::string& PSKErrorCode_Name(PSKErrorCode value) {
  return ::google::protobuf::internal::NameOfEnum(
    PSKErrorCode_descriptor(), value);
}
inline bool PSKErrorCode_Parse(
    const ::std::string& name, PSKErrorCode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<PSKErrorCode>(
    PSKErrorCode_descriptor(), name, value);
}
enum TransmitMode {
  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);
const TransmitMode TransmitMode_MIN = INVALID_TRANSMIT_MODE;
const TransmitMode TransmitMode_MAX = DATA_TIMEOUT;
const int TransmitMode_ARRAYSIZE = TransmitMode_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* TransmitMode_descriptor();
inline const ::std::string& TransmitMode_Name(TransmitMode value) {
  return ::google::protobuf::internal::NameOfEnum(
    TransmitMode_descriptor(), value);
}
inline bool TransmitMode_Parse(
    const ::std::string& name, TransmitMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TransmitMode>(
    TransmitMode_descriptor(), name, value);
}
enum TransmissionType {
  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);
const TransmissionType TransmissionType_MIN = BASE_TYPE;
const TransmissionType TransmissionType_MAX = MICROMODEM_M_SEQUENCE;
const int TransmissionType_ARRAYSIZE = TransmissionType_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* TransmissionType_descriptor();
inline const ::std::string& TransmissionType_Name(TransmissionType value) {
  return ::google::protobuf::internal::NameOfEnum(
    TransmissionType_descriptor(), value);
}
inline bool TransmissionType_Parse(
    const ::std::string& name, TransmissionType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TransmissionType>(
    TransmissionType_descriptor(), name, value);
}
enum HardwareLine {
  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);
const HardwareLine HardwareLine_MIN = MM1_EXTSEL1;
const HardwareLine HardwareLine_MAX = MM1_COM2;
const int HardwareLine_ARRAYSIZE = HardwareLine_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* HardwareLine_descriptor();
inline const ::std::string& HardwareLine_Name(HardwareLine value) {
  return ::google::protobuf::internal::NameOfEnum(
    HardwareLine_descriptor(), value);
}
inline bool HardwareLine_Parse(
    const ::std::string& name, HardwareLine* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HardwareLine>(
    HardwareLine_descriptor(), name, value);
}
enum HardwareControlMode {
  READ_LINE = 0,
  SET_VALUE = 1,
  TOGGLE_HIGH = 2,
  TOGGLE_LOW = 3
};
bool HardwareControlMode_IsValid(int value);
const HardwareControlMode HardwareControlMode_MIN = READ_LINE;
const HardwareControlMode HardwareControlMode_MAX = TOGGLE_LOW;
const int HardwareControlMode_ARRAYSIZE = HardwareControlMode_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* HardwareControlMode_descriptor();
inline const ::std::string& HardwareControlMode_Name(HardwareControlMode value) {
  return ::google::protobuf::internal::NameOfEnum(
    HardwareControlMode_descriptor(), value);
}
inline bool HardwareControlMode_Parse(
    const ::std::string& name, HardwareControlMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HardwareControlMode>(
    HardwareControlMode_descriptor(), name, value);
}
enum HardwareControlArgument {
  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);
const HardwareControlArgument HardwareControlArgument_MIN = MODE1_OFF;
const HardwareControlArgument HardwareControlArgument_MAX = TOGGLE_30_SEC;
const int HardwareControlArgument_ARRAYSIZE = HardwareControlArgument_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* HardwareControlArgument_descriptor();
inline const ::std::string& HardwareControlArgument_Name(HardwareControlArgument value) {
  return ::google::protobuf::internal::NameOfEnum(
    HardwareControlArgument_descriptor(), value);
}
inline bool HardwareControlArgument_Parse(
    const ::std::string& name, HardwareControlArgument* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HardwareControlArgument>(
    HardwareControlArgument_descriptor(), name, value);
}
// ===================================================================
 
class NarrowBandLBLParams : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.NarrowBandLBLParams) */ {
 public:
  NarrowBandLBLParams();
  virtual ~NarrowBandLBLParams();
 
  NarrowBandLBLParams(const NarrowBandLBLParams& from);
 
  inline NarrowBandLBLParams& operator=(const NarrowBandLBLParams& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NarrowBandLBLParams(NarrowBandLBLParams&& from) noexcept
    : NarrowBandLBLParams() {
    *this = ::std::move(from);
  }
 
  inline NarrowBandLBLParams& operator=(NarrowBandLBLParams&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const NarrowBandLBLParams& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NarrowBandLBLParams* internal_default_instance() {
    return reinterpret_cast<const NarrowBandLBLParams*>(
               &_NarrowBandLBLParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  void Swap(NarrowBandLBLParams* other);
  friend void swap(NarrowBandLBLParams& a, NarrowBandLBLParams& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline NarrowBandLBLParams* New() const final {
    return CreateMaybeMessage<NarrowBandLBLParams>(NULL);
  }
 
  NarrowBandLBLParams* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<NarrowBandLBLParams>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const NarrowBandLBLParams& from);
  void MergeFrom(const NarrowBandLBLParams& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NarrowBandLBLParams* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // repeated uint32 receive_freq = 3;
  int receive_freq_size() const;
  void clear_receive_freq();
  static const int kReceiveFreqFieldNumber = 3;
  ::google::protobuf::uint32 receive_freq(int index) const;
  void set_receive_freq(int index, ::google::protobuf::uint32 value);
  void add_receive_freq(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      receive_freq() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_receive_freq();
 
  // optional uint32 transmit_freq = 1;
  bool has_transmit_freq() const;
  void clear_transmit_freq();
  static const int kTransmitFreqFieldNumber = 1;
  ::google::protobuf::uint32 transmit_freq() const;
  void set_transmit_freq(::google::protobuf::uint32 value);
 
  // optional uint32 transmit_ping_ms = 2;
  bool has_transmit_ping_ms() const;
  void clear_transmit_ping_ms();
  static const int kTransmitPingMsFieldNumber = 2;
  ::google::protobuf::uint32 transmit_ping_ms() const;
  void set_transmit_ping_ms(::google::protobuf::uint32 value);
 
  // optional uint32 receive_ping_ms = 4;
  bool has_receive_ping_ms() const;
  void clear_receive_ping_ms();
  static const int kReceivePingMsFieldNumber = 4;
  ::google::protobuf::uint32 receive_ping_ms() const;
  void set_receive_ping_ms(::google::protobuf::uint32 value);
 
  // optional uint32 turnaround_ms = 5;
  bool has_turnaround_ms() const;
  void clear_turnaround_ms();
  static const int kTurnaroundMsFieldNumber = 5;
  ::google::protobuf::uint32 turnaround_ms() const;
  void set_turnaround_ms(::google::protobuf::uint32 value);
 
  // optional bool transmit_flag = 6 [default = true];
  bool has_transmit_flag() const;
  void clear_transmit_flag();
  static const int kTransmitFlagFieldNumber = 6;
  bool transmit_flag() const;
  void set_transmit_flag(bool value);
 
  // optional uint32 lbl_max_range = 7 [default = 2000];
  bool has_lbl_max_range() const;
  void clear_lbl_max_range();
  static const int kLblMaxRangeFieldNumber = 7;
  ::google::protobuf::uint32 lbl_max_range() const;
  void set_lbl_max_range(::google::protobuf::uint32 value);
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.NarrowBandLBLParams)
 private:
  void set_has_transmit_freq();
  void clear_has_transmit_freq();
  void set_has_transmit_ping_ms();
  void clear_has_transmit_ping_ms();
  void set_has_receive_ping_ms();
  void clear_has_receive_ping_ms();
  void set_has_turnaround_ms();
  void clear_has_turnaround_ms();
  void set_has_transmit_flag();
  void clear_has_transmit_flag();
  void set_has_lbl_max_range();
  void clear_has_lbl_max_range();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > receive_freq_;
  ::google::protobuf::uint32 transmit_freq_;
  ::google::protobuf::uint32 transmit_ping_ms_;
  ::google::protobuf::uint32 receive_ping_ms_;
  ::google::protobuf::uint32 turnaround_ms_;
  bool transmit_flag_;
  ::google::protobuf::uint32 lbl_max_range_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class REMUSLBLParams : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.REMUSLBLParams) */ {
 public:
  REMUSLBLParams();
  virtual ~REMUSLBLParams();
 
  REMUSLBLParams(const REMUSLBLParams& from);
 
  inline REMUSLBLParams& operator=(const REMUSLBLParams& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  REMUSLBLParams(REMUSLBLParams&& from) noexcept
    : REMUSLBLParams() {
    *this = ::std::move(from);
  }
 
  inline REMUSLBLParams& operator=(REMUSLBLParams&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const REMUSLBLParams& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const REMUSLBLParams* internal_default_instance() {
    return reinterpret_cast<const REMUSLBLParams*>(
               &_REMUSLBLParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  void Swap(REMUSLBLParams* other);
  friend void swap(REMUSLBLParams& a, REMUSLBLParams& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline REMUSLBLParams* New() const final {
    return CreateMaybeMessage<REMUSLBLParams>(NULL);
  }
 
  REMUSLBLParams* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<REMUSLBLParams>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const REMUSLBLParams& from);
  void MergeFrom(const REMUSLBLParams& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(REMUSLBLParams* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional uint32 lbl_max_range = 3 [default = 1000];
  bool has_lbl_max_range() const;
  void clear_lbl_max_range();
  static const int kLblMaxRangeFieldNumber = 3;
  ::google::protobuf::uint32 lbl_max_range() const;
  void set_lbl_max_range(::google::protobuf::uint32 value);
 
  // optional uint32 enable_beacons = 1 [default = 15];
  bool has_enable_beacons() const;
  void clear_enable_beacons();
  static const int kEnableBeaconsFieldNumber = 1;
  ::google::protobuf::uint32 enable_beacons() const;
  void set_enable_beacons(::google::protobuf::uint32 value);
 
  // optional uint32 turnaround_ms = 2 [default = 50];
  bool has_turnaround_ms() const;
  void clear_turnaround_ms();
  static const int kTurnaroundMsFieldNumber = 2;
  ::google::protobuf::uint32 turnaround_ms() const;
  void set_turnaround_ms(::google::protobuf::uint32 value);
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.REMUSLBLParams)
 private:
  void set_has_enable_beacons();
  void clear_has_enable_beacons();
  void set_has_turnaround_ms();
  void clear_has_turnaround_ms();
  void set_has_lbl_max_range();
  void clear_has_lbl_max_range();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 lbl_max_range_;
  ::google::protobuf::uint32 enable_beacons_;
  ::google::protobuf::uint32 turnaround_ms_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class GenericLBLParams : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.GenericLBLParams) */ {
 public:
  GenericLBLParams();
  virtual ~GenericLBLParams();
 
  GenericLBLParams(const GenericLBLParams& from);
 
  inline GenericLBLParams& operator=(const GenericLBLParams& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  GenericLBLParams(GenericLBLParams&& from) noexcept
    : GenericLBLParams() {
    *this = ::std::move(from);
  }
 
  inline GenericLBLParams& operator=(GenericLBLParams&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GenericLBLParams& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GenericLBLParams* internal_default_instance() {
    return reinterpret_cast<const GenericLBLParams*>(
               &_GenericLBLParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  void Swap(GenericLBLParams* other);
  friend void swap(GenericLBLParams& a, GenericLBLParams& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline GenericLBLParams* New() const final {
    return CreateMaybeMessage<GenericLBLParams>(NULL);
  }
 
  GenericLBLParams* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<GenericLBLParams>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const GenericLBLParams& from);
  void MergeFrom(const GenericLBLParams& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GenericLBLParams* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // repeated uint64 receive_seq_code = 5;
  int receive_seq_code_size() const;
  void clear_receive_seq_code();
  static const int kReceiveSeqCodeFieldNumber = 5;
  ::google::protobuf::uint64 receive_seq_code(int index) const;
  void set_receive_seq_code(int index, ::google::protobuf::uint64 value);
  void add_receive_seq_code(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      receive_seq_code() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_receive_seq_code();
 
  // optional uint32 transmit_freq = 1;
  bool has_transmit_freq() const;
  void clear_transmit_freq();
  static const int kTransmitFreqFieldNumber = 1;
  ::google::protobuf::uint32 transmit_freq() const;
  void set_transmit_freq(::google::protobuf::uint32 value);
 
  // optional uint32 n_bits = 2;
  bool has_n_bits() const;
  void clear_n_bits();
  static const int kNBitsFieldNumber = 2;
  ::google::protobuf::uint32 n_bits() const;
  void set_n_bits(::google::protobuf::uint32 value);
 
  // optional uint64 transmit_seq_code = 3;
  bool has_transmit_seq_code() const;
  void clear_transmit_seq_code();
  static const int kTransmitSeqCodeFieldNumber = 3;
  ::google::protobuf::uint64 transmit_seq_code() const;
  void set_transmit_seq_code(::google::protobuf::uint64 value);
 
  // optional uint32 receive_freq = 4;
  bool has_receive_freq() const;
  void clear_receive_freq();
  static const int kReceiveFreqFieldNumber = 4;
  ::google::protobuf::uint32 receive_freq() const;
  void set_receive_freq(::google::protobuf::uint32 value);
 
  // optional uint32 bandwidth = 6;
  bool has_bandwidth() const;
  void clear_bandwidth();
  static const int kBandwidthFieldNumber = 6;
  ::google::protobuf::uint32 bandwidth() const;
  void set_bandwidth(::google::protobuf::uint32 value);
 
  // optional uint32 turnaround_ms = 7;
  bool has_turnaround_ms() const;
  void clear_turnaround_ms();
  static const int kTurnaroundMsFieldNumber = 7;
  ::google::protobuf::uint32 turnaround_ms() const;
  void set_turnaround_ms(::google::protobuf::uint32 value);
 
  // optional uint32 lbl_max_range = 8 [default = 2000];
  bool has_lbl_max_range() const;
  void clear_lbl_max_range();
  static const int kLblMaxRangeFieldNumber = 8;
  ::google::protobuf::uint32 lbl_max_range() const;
  void set_lbl_max_range(::google::protobuf::uint32 value);
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.GenericLBLParams)
 private:
  void set_has_transmit_freq();
  void clear_has_transmit_freq();
  void set_has_n_bits();
  void clear_has_n_bits();
  void set_has_transmit_seq_code();
  void clear_has_transmit_seq_code();
  void set_has_receive_freq();
  void clear_has_receive_freq();
  void set_has_bandwidth();
  void clear_has_bandwidth();
  void set_has_turnaround_ms();
  void clear_has_turnaround_ms();
  void set_has_lbl_max_range();
  void clear_has_lbl_max_range();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > receive_seq_code_;
  ::google::protobuf::uint32 transmit_freq_;
  ::google::protobuf::uint32 n_bits_;
  ::google::protobuf::uint64 transmit_seq_code_;
  ::google::protobuf::uint32 receive_freq_;
  ::google::protobuf::uint32 bandwidth_;
  ::google::protobuf::uint32 turnaround_ms_;
  ::google::protobuf::uint32 lbl_max_range_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class FMSweepParams : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.FMSweepParams) */ {
 public:
  FMSweepParams();
  virtual ~FMSweepParams();
 
  FMSweepParams(const FMSweepParams& from);
 
  inline FMSweepParams& operator=(const FMSweepParams& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  FMSweepParams(FMSweepParams&& from) noexcept
    : FMSweepParams() {
    *this = ::std::move(from);
  }
 
  inline FMSweepParams& operator=(FMSweepParams&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const FMSweepParams& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const FMSweepParams* internal_default_instance() {
    return reinterpret_cast<const FMSweepParams*>(
               &_FMSweepParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  void Swap(FMSweepParams* other);
  friend void swap(FMSweepParams& a, FMSweepParams& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline FMSweepParams* New() const final {
    return CreateMaybeMessage<FMSweepParams>(NULL);
  }
 
  FMSweepParams* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<FMSweepParams>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const FMSweepParams& from);
  void MergeFrom(const FMSweepParams& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FMSweepParams* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required double start_freq = 1;
  bool has_start_freq() const;
  void clear_start_freq();
  static const int kStartFreqFieldNumber = 1;
  double start_freq() const;
  void set_start_freq(double value);
 
  // required double stop_freq = 2;
  bool has_stop_freq() const;
  void clear_stop_freq();
  static const int kStopFreqFieldNumber = 2;
  double stop_freq() const;
  void set_stop_freq(double value);
 
  // required double duration_ms = 3;
  bool has_duration_ms() const;
  void clear_duration_ms();
  static const int kDurationMsFieldNumber = 3;
  double duration_ms() const;
  void set_duration_ms(double value);
 
  // optional uint32 number_repetitions = 4 [default = 1];
  bool has_number_repetitions() const;
  void clear_number_repetitions();
  static const int kNumberRepetitionsFieldNumber = 4;
  ::google::protobuf::uint32 number_repetitions() const;
  void set_number_repetitions(::google::protobuf::uint32 value);
 
  // optional double repetition_period_ms = 5 [default = 1000];
  bool has_repetition_period_ms() const;
  void clear_repetition_period_ms();
  static const int kRepetitionPeriodMsFieldNumber = 5;
  double repetition_period_ms() const;
  void set_repetition_period_ms(double value);
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.FMSweepParams)
 private:
  void set_has_start_freq();
  void clear_has_start_freq();
  void set_has_stop_freq();
  void clear_has_stop_freq();
  void set_has_duration_ms();
  void clear_has_duration_ms();
  void set_has_number_repetitions();
  void clear_has_number_repetitions();
  void set_has_repetition_period_ms();
  void clear_has_repetition_period_ms();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  double start_freq_;
  double stop_freq_;
  double duration_ms_;
  ::google::protobuf::uint32 number_repetitions_;
  double repetition_period_ms_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class MSequenceParams : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.MSequenceParams) */ {
 public:
  MSequenceParams();
  virtual ~MSequenceParams();
 
  MSequenceParams(const MSequenceParams& from);
 
  inline MSequenceParams& operator=(const MSequenceParams& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  MSequenceParams(MSequenceParams&& from) noexcept
    : MSequenceParams() {
    *this = ::std::move(from);
  }
 
  inline MSequenceParams& operator=(MSequenceParams&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const MSequenceParams& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MSequenceParams* internal_default_instance() {
    return reinterpret_cast<const MSequenceParams*>(
               &_MSequenceParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  void Swap(MSequenceParams* other);
  friend void swap(MSequenceParams& a, MSequenceParams& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline MSequenceParams* New() const final {
    return CreateMaybeMessage<MSequenceParams>(NULL);
  }
 
  MSequenceParams* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<MSequenceParams>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const MSequenceParams& from);
  void MergeFrom(const MSequenceParams& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MSequenceParams* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required uint32 seqlen_bits = 1;
  bool has_seqlen_bits() const;
  void clear_seqlen_bits();
  static const int kSeqlenBitsFieldNumber = 1;
  ::google::protobuf::uint32 seqlen_bits() const;
  void set_seqlen_bits(::google::protobuf::uint32 value);
 
  // required uint32 number_repetitions = 2;
  bool has_number_repetitions() const;
  void clear_number_repetitions();
  static const int kNumberRepetitionsFieldNumber = 2;
  ::google::protobuf::uint32 number_repetitions() const;
  void set_number_repetitions(::google::protobuf::uint32 value);
 
  // required uint32 carrier_cycles_per_chip = 3;
  bool has_carrier_cycles_per_chip() const;
  void clear_carrier_cycles_per_chip();
  static const int kCarrierCyclesPerChipFieldNumber = 3;
  ::google::protobuf::uint32 carrier_cycles_per_chip() const;
  void set_carrier_cycles_per_chip(::google::protobuf::uint32 value);
 
  // required uint32 carrier_freq = 4;
  bool has_carrier_freq() const;
  void clear_carrier_freq();
  static const int kCarrierFreqFieldNumber = 4;
  ::google::protobuf::uint32 carrier_freq() const;
  void set_carrier_freq(::google::protobuf::uint32 value);
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.MSequenceParams)
 private:
  void set_has_seqlen_bits();
  void clear_has_seqlen_bits();
  void set_has_number_repetitions();
  void clear_has_number_repetitions();
  void set_has_carrier_cycles_per_chip();
  void clear_has_carrier_cycles_per_chip();
  void set_has_carrier_freq();
  void clear_has_carrier_freq();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 seqlen_bits_;
  ::google::protobuf::uint32 number_repetitions_;
  ::google::protobuf::uint32 carrier_cycles_per_chip_;
  ::google::protobuf::uint32 carrier_freq_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class Config_Revision : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.Config.Revision) */ {
 public:
  Config_Revision();
  virtual ~Config_Revision();
 
  Config_Revision(const Config_Revision& from);
 
  inline Config_Revision& operator=(const Config_Revision& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Config_Revision(Config_Revision&& from) noexcept
    : Config_Revision() {
    *this = ::std::move(from);
  }
 
  inline Config_Revision& operator=(Config_Revision&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const Config_Revision& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Config_Revision* internal_default_instance() {
    return reinterpret_cast<const Config_Revision*>(
               &_Config_Revision_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  void Swap(Config_Revision* other);
  friend void swap(Config_Revision& a, Config_Revision& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline Config_Revision* New() const final {
    return CreateMaybeMessage<Config_Revision>(NULL);
  }
 
  Config_Revision* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Config_Revision>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Config_Revision& from);
  void MergeFrom(const Config_Revision& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Config_Revision* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required int32 mm_major = 1;
  bool has_mm_major() const;
  void clear_mm_major();
  static const int kMmMajorFieldNumber = 1;
  ::google::protobuf::int32 mm_major() const;
  void set_mm_major(::google::protobuf::int32 value);
 
  // required int32 mm_minor = 2;
  bool has_mm_minor() const;
  void clear_mm_minor();
  static const int kMmMinorFieldNumber = 2;
  ::google::protobuf::int32 mm_minor() const;
  void set_mm_minor(::google::protobuf::int32 value);
 
  // required int32 mm_patch = 3;
  bool has_mm_patch() const;
  void clear_mm_patch();
  static const int kMmPatchFieldNumber = 3;
  ::google::protobuf::int32 mm_patch() const;
  void set_mm_patch(::google::protobuf::int32 value);
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.Config.Revision)
 private:
  void set_has_mm_major();
  void clear_has_mm_major();
  void set_has_mm_minor();
  void clear_has_mm_minor();
  void set_has_mm_patch();
  void clear_has_mm_patch();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 mm_major_;
  ::google::protobuf::int32 mm_minor_;
  ::google::protobuf::int32 mm_patch_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class Config : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.Config) */ {
 public:
  Config();
  virtual ~Config();
 
  Config(const Config& from);
 
  inline Config& operator=(const Config& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Config(Config&& from) noexcept
    : Config() {
    *this = ::std::move(from);
  }
 
  inline Config& operator=(Config&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const Config& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Config* internal_default_instance() {
    return reinterpret_cast<const Config*>(
               &_Config_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  void Swap(Config* other);
  friend void swap(Config& a, Config& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline Config* New() const final {
    return CreateMaybeMessage<Config>(NULL);
  }
 
  Config* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Config>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Config& from);
  void MergeFrom(const Config& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Config* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef Config_Revision Revision;
 
  // accessors -------------------------------------------------------
 
  // repeated string nvram_cfg = 2;
  int nvram_cfg_size() const;
  void clear_nvram_cfg();
  static const int kNvramCfgFieldNumber = 2;
  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);
  #if LANG_CXX11
  void set_nvram_cfg(int index, ::std::string&& value);
  #endif
  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);
  #if LANG_CXX11
  void add_nvram_cfg(::std::string&& value);
  #endif
  void add_nvram_cfg(const char* value);
  void add_nvram_cfg(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& nvram_cfg() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_nvram_cfg();
 
  // repeated uint32 additional_application_ack_modem_id = 21;
  int additional_application_ack_modem_id_size() const;
  void clear_additional_application_ack_modem_id();
  static const int kAdditionalApplicationAckModemIdFieldNumber = 21;
  ::google::protobuf::uint32 additional_application_ack_modem_id(int index) const;
  void set_additional_application_ack_modem_id(int index, ::google::protobuf::uint32 value);
  void add_additional_application_ack_modem_id(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      additional_application_ack_modem_id() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_additional_application_ack_modem_id();
 
  // optional .goby.acomms.micromodem.protobuf.NarrowBandLBLParams narrowband_lbl = 4;
  bool has_narrowband_lbl() const;
  void clear_narrowband_lbl();
  static const int kNarrowbandLblFieldNumber = 4;
  private:
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& _internal_narrowband_lbl() const;
  public:
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& narrowband_lbl() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.REMUSLBLParams remus_lbl = 5;
  bool has_remus_lbl() const;
  void clear_remus_lbl();
  static const int kRemusLblFieldNumber = 5;
  private:
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& _internal_remus_lbl() const;
  public:
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& remus_lbl() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.GenericLBLParams generic_lbl = 8;
  bool has_generic_lbl() const;
  void clear_generic_lbl();
  static const int kGenericLblFieldNumber = 8;
  private:
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams& _internal_generic_lbl() const;
  public:
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams& generic_lbl() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.FMSweepParams fm_sweep = 9;
  bool has_fm_sweep() const;
  void clear_fm_sweep();
  static const int kFmSweepFieldNumber = 9;
  private:
  const ::goby::acomms::micromodem::protobuf::FMSweepParams& _internal_fm_sweep() const;
  public:
  const ::goby::acomms::micromodem::protobuf::FMSweepParams& fm_sweep() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.MSequenceParams m_sequence = 10;
  bool has_m_sequence() const;
  void clear_m_sequence();
  static const int kMSequenceFieldNumber = 10;
  private:
  const ::goby::acomms::micromodem::protobuf::MSequenceParams& _internal_m_sequence() const;
  public:
  const ::goby::acomms::micromodem::protobuf::MSequenceParams& m_sequence() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.Config.Revision revision = 30;
  bool has_revision() const;
  void clear_revision();
  static const int kRevisionFieldNumber = 30;
  private:
  const ::goby::acomms::micromodem::protobuf::Config_Revision& _internal_revision() const;
  public:
  const ::goby::acomms::micromodem::protobuf::Config_Revision& revision() const;
  ::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);
 
  // optional uint32 hydroid_gateway_id = 3 [default = 0];
  bool has_hydroid_gateway_id() const;
  void clear_hydroid_gateway_id();
  static const int kHydroidGatewayIdFieldNumber = 3;
  ::google::protobuf::uint32 hydroid_gateway_id() const;
  void set_hydroid_gateway_id(::google::protobuf::uint32 value);
 
  // optional bool reset_nvram = 1 [default = false];
  bool has_reset_nvram() const;
  void clear_reset_nvram();
  static const int kResetNvramFieldNumber = 1;
  bool reset_nvram() const;
  void set_reset_nvram(bool value);
 
  // optional bool use_application_acks = 20 [default = false];
  bool has_use_application_acks() const;
  void clear_use_application_acks();
  static const int kUseApplicationAcksFieldNumber = 20;
  bool use_application_acks() const;
  void set_use_application_acks(bool value);
 
  // optional bool pad_partial_frames = 23 [default = false, (.goby.field) = {
  bool has_pad_partial_frames() const;
  void clear_pad_partial_frames();
  static const int kPadPartialFramesFieldNumber = 23;
  bool pad_partial_frames() const;
  void set_pad_partial_frames(bool value);
 
  // optional bool use_base64_fdp = 40 [default = false];
  bool has_use_base64_fdp() const;
  void clear_use_base64_fdp();
  static const int kUseBase64FdpFieldNumber = 40;
  bool use_base64_fdp() const;
  void set_use_base64_fdp(bool value);
 
  // optional bool query_cfg_on_startup = 22 [default = true];
  bool has_query_cfg_on_startup() const;
  void clear_query_cfg_on_startup();
  static const int kQueryCfgOnStartupFieldNumber = 22;
  bool query_cfg_on_startup() const;
  void set_query_cfg_on_startup(bool value);
 
  // optional int32 keep_alive_seconds = 6 [default = 10];
  bool has_keep_alive_seconds() const;
  void clear_keep_alive_seconds();
  static const int kKeepAliveSecondsFieldNumber = 6;
  ::google::protobuf::int32 keep_alive_seconds() const;
  void set_keep_alive_seconds(::google::protobuf::int32 value);
 
  // optional int32 allowed_skew_ms = 7 [default = 1000];
  bool has_allowed_skew_ms() const;
  void clear_allowed_skew_ms();
  static const int kAllowedSkewMsFieldNumber = 7;
  ::google::protobuf::int32 allowed_skew_ms() const;
  void set_allowed_skew_ms(::google::protobuf::int32 value);
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.Config)
 private:
  void set_has_reset_nvram();
  void clear_has_reset_nvram();
  void set_has_hydroid_gateway_id();
  void clear_has_hydroid_gateway_id();
  void set_has_narrowband_lbl();
  void clear_has_narrowband_lbl();
  void set_has_remus_lbl();
  void clear_has_remus_lbl();
  void set_has_keep_alive_seconds();
  void clear_has_keep_alive_seconds();
  void set_has_allowed_skew_ms();
  void clear_has_allowed_skew_ms();
  void set_has_generic_lbl();
  void clear_has_generic_lbl();
  void set_has_fm_sweep();
  void clear_has_fm_sweep();
  void set_has_m_sequence();
  void clear_has_m_sequence();
  void set_has_use_application_acks();
  void clear_has_use_application_acks();
  void set_has_query_cfg_on_startup();
  void clear_has_query_cfg_on_startup();
  void set_has_pad_partial_frames();
  void clear_has_pad_partial_frames();
  void set_has_revision();
  void clear_has_revision();
  void set_has_use_base64_fdp();
  void clear_has_use_base64_fdp();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> nvram_cfg_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > 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_;
  ::google::protobuf::uint32 hydroid_gateway_id_;
  bool reset_nvram_;
  bool use_application_acks_;
  bool pad_partial_frames_;
  bool use_base64_fdp_;
  bool query_cfg_on_startup_;
  ::google::protobuf::int32 keep_alive_seconds_;
  ::google::protobuf::int32 allowed_skew_ms_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RangingReply : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.RangingReply) */ {
 public:
  RangingReply();
  virtual ~RangingReply();
 
  RangingReply(const RangingReply& from);
 
  inline RangingReply& operator=(const RangingReply& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RangingReply(RangingReply&& from) noexcept
    : RangingReply() {
    *this = ::std::move(from);
  }
 
  inline RangingReply& operator=(RangingReply&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const RangingReply& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RangingReply* internal_default_instance() {
    return reinterpret_cast<const RangingReply*>(
               &_RangingReply_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;
 
  void Swap(RangingReply* other);
  friend void swap(RangingReply& a, RangingReply& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RangingReply* New() const final {
    return CreateMaybeMessage<RangingReply>(NULL);
  }
 
  RangingReply* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RangingReply>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RangingReply& from);
  void MergeFrom(const RangingReply& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangingReply* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef RangingReply_OWTTAmbiguity OWTTAmbiguity;
  static const OWTTAmbiguity OWTT_EXACT =
    RangingReply_OWTTAmbiguity_OWTT_EXACT;
  static const OWTTAmbiguity OWTT_SECOND_AMBIGUOUS =
    RangingReply_OWTTAmbiguity_OWTT_SECOND_AMBIGUOUS;
  static inline bool OWTTAmbiguity_IsValid(int value) {
    return RangingReply_OWTTAmbiguity_IsValid(value);
  }
  static const OWTTAmbiguity OWTTAmbiguity_MIN =
    RangingReply_OWTTAmbiguity_OWTTAmbiguity_MIN;
  static const OWTTAmbiguity OWTTAmbiguity_MAX =
    RangingReply_OWTTAmbiguity_OWTTAmbiguity_MAX;
  static const int OWTTAmbiguity_ARRAYSIZE =
    RangingReply_OWTTAmbiguity_OWTTAmbiguity_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  OWTTAmbiguity_descriptor() {
    return RangingReply_OWTTAmbiguity_descriptor();
  }
  static inline const ::std::string& OWTTAmbiguity_Name(OWTTAmbiguity value) {
    return RangingReply_OWTTAmbiguity_Name(value);
  }
  static inline bool OWTTAmbiguity_Parse(const ::std::string& name,
      OWTTAmbiguity* value) {
    return RangingReply_OWTTAmbiguity_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  // repeated double one_way_travel_time = 1 [(.dccl.field) = {
  int one_way_travel_time_size() const;
  void clear_one_way_travel_time();
  static const int kOneWayTravelTimeFieldNumber = 1;
  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 ::google::protobuf::RepeatedField< double >&
      one_way_travel_time() const;
  ::google::protobuf::RepeatedField< double >*
      mutable_one_way_travel_time();
 
  // optional bool is_one_way_synchronous = 3 [default = false];
  bool has_is_one_way_synchronous() const;
  void clear_is_one_way_synchronous();
  static const int kIsOneWaySynchronousFieldNumber = 3;
  bool is_one_way_synchronous() const;
  void set_is_one_way_synchronous(bool value);
 
  // optional .goby.acomms.micromodem.protobuf.ClockMode receiver_clk_mode = 4 [default = NO_SYNC_TO_PPS_AND_CCCLK_BAD];
  bool has_receiver_clk_mode() const;
  void clear_receiver_clk_mode();
  static const int kReceiverClkModeFieldNumber = 4;
  ::goby::acomms::micromodem::protobuf::ClockMode receiver_clk_mode() const;
  void set_receiver_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
 
  // optional .goby.acomms.micromodem.protobuf.ClockMode sender_clk_mode = 5 [default = NO_SYNC_TO_PPS_AND_CCCLK_BAD];
  bool has_sender_clk_mode() const;
  void clear_sender_clk_mode();
  static const int kSenderClkModeFieldNumber = 5;
  ::goby::acomms::micromodem::protobuf::ClockMode sender_clk_mode() const;
  void set_sender_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
 
  // optional .goby.acomms.micromodem.protobuf.RangingReply.OWTTAmbiguity ambiguity = 2 [default = OWTT_EXACT];
  bool has_ambiguity() const;
  void clear_ambiguity();
  static const int kAmbiguityFieldNumber = 2;
  ::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity ambiguity() const;
  void set_ambiguity(::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity value);
 
  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:
  void set_has_ambiguity();
  void clear_has_ambiguity();
  void set_has_is_one_way_synchronous();
  void clear_has_is_one_way_synchronous();
  void set_has_receiver_clk_mode();
  void clear_has_receiver_clk_mode();
  void set_has_sender_clk_mode();
  void clear_has_sender_clk_mode();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< double > one_way_travel_time_;
  bool is_one_way_synchronous_;
  int receiver_clk_mode_;
  int sender_clk_mode_;
  int ambiguity_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReceiveStatistics : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.ReceiveStatistics) */ {
 public:
  ReceiveStatistics();
  virtual ~ReceiveStatistics();
 
  ReceiveStatistics(const ReceiveStatistics& from);
 
  inline ReceiveStatistics& operator=(const ReceiveStatistics& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReceiveStatistics(ReceiveStatistics&& from) noexcept
    : ReceiveStatistics() {
    *this = ::std::move(from);
  }
 
  inline ReceiveStatistics& operator=(ReceiveStatistics&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReceiveStatistics& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReceiveStatistics* internal_default_instance() {
    return reinterpret_cast<const ReceiveStatistics*>(
               &_ReceiveStatistics_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;
 
  void Swap(ReceiveStatistics* other);
  friend void swap(ReceiveStatistics& a, ReceiveStatistics& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReceiveStatistics* New() const final {
    return CreateMaybeMessage<ReceiveStatistics>(NULL);
  }
 
  ReceiveStatistics* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReceiveStatistics>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReceiveStatistics& from);
  void MergeFrom(const ReceiveStatistics& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReceiveStatistics* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string date = 31 [(.dccl.field) = {
  bool has_date() const;
  void clear_date();
  static const int kDateFieldNumber = 31;
  const ::std::string& date() const;
  void set_date(const ::std::string& value);
  #if LANG_CXX11
  void set_date(::std::string&& value);
  #endif
  void set_date(const char* value);
  void set_date(const char* value, size_t size);
  ::std::string* mutable_date();
  ::std::string* release_date();
  void set_allocated_date(::std::string* date);
 
  // required uint64 time = 2 [(.dccl.field) = {
  bool has_time() const;
  void clear_time();
  static const int kTimeFieldNumber = 2;
  ::google::protobuf::uint64 time() const;
  void set_time(::google::protobuf::uint64 value);
 
  // optional int32 mfd_peak = 4 [(.dccl.field) = {
  bool has_mfd_peak() const;
  void clear_mfd_peak();
  static const int kMfdPeakFieldNumber = 4;
  ::google::protobuf::int32 mfd_peak() const;
  void set_mfd_peak(::google::protobuf::int32 value);
 
  // required int32 mfd_power = 5 [(.dccl.field) = {
  bool has_mfd_power() const;
  void clear_mfd_power();
  static const int kMfdPowerFieldNumber = 5;
  ::google::protobuf::int32 mfd_power() const;
  void set_mfd_power(::google::protobuf::int32 value);
 
  // required int32 mfd_ratio = 6 [(.dccl.field) = {
  bool has_mfd_ratio() const;
  void clear_mfd_ratio();
  static const int kMfdRatioFieldNumber = 6;
  ::google::protobuf::int32 mfd_ratio() const;
  void set_mfd_ratio(::google::protobuf::int32 value);
 
  // optional int32 spl = 7 [(.dccl.field) = {
  bool has_spl() const;
  void clear_spl();
  static const int kSplFieldNumber = 7;
  ::google::protobuf::int32 spl() const;
  void set_spl(::google::protobuf::int32 value);
 
  // optional int32 shf_agn = 8 [(.dccl.field) = {
  bool has_shf_agn() const;
  void clear_shf_agn();
  static const int kShfAgnFieldNumber = 8;
  ::google::protobuf::int32 shf_agn() const;
  void set_shf_agn(::google::protobuf::int32 value);
 
  // optional int32 shf_ainpshift = 9 [(.dccl.field) = {
  bool has_shf_ainpshift() const;
  void clear_shf_ainpshift();
  static const int kShfAinpshiftFieldNumber = 9;
  ::google::protobuf::int32 shf_ainpshift() const;
  void set_shf_ainpshift(::google::protobuf::int32 value);
 
  // optional int32 shf_ainshift = 10 [(.dccl.field) = {
  bool has_shf_ainshift() const;
  void clear_shf_ainshift();
  static const int kShfAinshiftFieldNumber = 10;
  ::google::protobuf::int32 shf_ainshift() const;
  void set_shf_ainshift(::google::protobuf::int32 value);
 
  // optional int32 shf_mfdshift = 11 [(.dccl.field) = {
  bool has_shf_mfdshift() const;
  void clear_shf_mfdshift();
  static const int kShfMfdshiftFieldNumber = 11;
  ::google::protobuf::int32 shf_mfdshift() const;
  void set_shf_mfdshift(::google::protobuf::int32 value);
 
  // optional int32 shf_p2bshift = 12 [(.dccl.field) = {
  bool has_shf_p2bshift() const;
  void clear_shf_p2bshift();
  static const int kShfP2BshiftFieldNumber = 12;
  ::google::protobuf::int32 shf_p2bshift() const;
  void set_shf_p2bshift(::google::protobuf::int32 value);
 
  // required int32 rate = 13 [(.dccl.field) = {
  bool has_rate() const;
  void clear_rate();
  static const int kRateFieldNumber = 13;
  ::google::protobuf::int32 rate() const;
  void set_rate(::google::protobuf::int32 value);
 
  // required int32 source = 14 [(.dccl.field) = {
  bool has_source() const;
  void clear_source();
  static const int kSourceFieldNumber = 14;
  ::google::protobuf::int32 source() const;
  void set_source(::google::protobuf::int32 value);
 
  // required int32 dest = 15 [(.dccl.field) = {
  bool has_dest() const;
  void clear_dest();
  static const int kDestFieldNumber = 15;
  ::google::protobuf::int32 dest() const;
  void set_dest(::google::protobuf::int32 value);
 
  // required int32 number_frames = 18 [(.dccl.field) = {
  bool has_number_frames() const;
  void clear_number_frames();
  static const int kNumberFramesFieldNumber = 18;
  ::google::protobuf::int32 number_frames() const;
  void set_number_frames(::google::protobuf::int32 value);
 
  // required int32 number_bad_frames = 19 [(.dccl.field) = {
  bool has_number_bad_frames() const;
  void clear_number_bad_frames();
  static const int kNumberBadFramesFieldNumber = 19;
  ::google::protobuf::int32 number_bad_frames() const;
  void set_number_bad_frames(::google::protobuf::int32 value);
 
  // required int32 snr_rss = 20 [(.dccl.field) = {
  bool has_snr_rss() const;
  void clear_snr_rss();
  static const int kSnrRssFieldNumber = 20;
  ::google::protobuf::int32 snr_rss() const;
  void set_snr_rss(::google::protobuf::int32 value);
 
  // required int32 snr_in = 21 [(.dccl.field) = {
  bool has_snr_in() const;
  void clear_snr_in();
  static const int kSnrInFieldNumber = 21;
  ::google::protobuf::int32 snr_in() const;
  void set_snr_in(::google::protobuf::int32 value);
 
  // required int32 snr_out = 22 [(.dccl.field) = {
  bool has_snr_out() const;
  void clear_snr_out();
  static const int kSnrOutFieldNumber = 22;
  ::google::protobuf::int32 snr_out() const;
  void set_snr_out(::google::protobuf::int32 value);
 
  // required int32 snr_symbols = 23 [(.dccl.field) = {
  bool has_snr_symbols() const;
  void clear_snr_symbols();
  static const int kSnrSymbolsFieldNumber = 23;
  ::google::protobuf::int32 snr_symbols() const;
  void set_snr_symbols(::google::protobuf::int32 value);
 
  // required int32 mse_equalizer = 24 [(.dccl.field) = {
  bool has_mse_equalizer() const;
  void clear_mse_equalizer();
  static const int kMseEqualizerFieldNumber = 24;
  ::google::protobuf::int32 mse_equalizer() const;
  void set_mse_equalizer(::google::protobuf::int32 value);
 
  // required int32 data_quality_factor = 25 [(.dccl.field) = {
  bool has_data_quality_factor() const;
  void clear_data_quality_factor();
  static const int kDataQualityFactorFieldNumber = 25;
  ::google::protobuf::int32 data_quality_factor() const;
  void set_data_quality_factor(::google::protobuf::int32 value);
 
  // required double doppler = 26 [(.dccl.field) = {
  bool has_doppler() const;
  void clear_doppler();
  static const int kDopplerFieldNumber = 26;
  double doppler() const;
  void set_doppler(double value);
 
  // required int32 stddev_noise = 27 [(.dccl.field) = {
  bool has_stddev_noise() const;
  void clear_stddev_noise();
  static const int kStddevNoiseFieldNumber = 27;
  ::google::protobuf::int32 stddev_noise() const;
  void set_stddev_noise(::google::protobuf::int32 value);
 
  // required int32 carrier_freq = 28 [(.dccl.field) = {
  bool has_carrier_freq() const;
  void clear_carrier_freq();
  static const int kCarrierFreqFieldNumber = 28;
  ::google::protobuf::int32 carrier_freq() const;
  void set_carrier_freq(::google::protobuf::int32 value);
 
  // required int32 bandwidth = 29 [(.dccl.field) = {
  bool has_bandwidth() const;
  void clear_bandwidth();
  static const int kBandwidthFieldNumber = 29;
  ::google::protobuf::int32 bandwidth() const;
  void set_bandwidth(::google::protobuf::int32 value);
 
  // optional int32 version = 30 [default = 0, (.dccl.field) = {
  bool has_version() const;
  void clear_version();
  static const int kVersionFieldNumber = 30;
  ::google::protobuf::int32 version() const;
  void set_version(::google::protobuf::int32 value);
 
  // optional int32 pcm = 32 [(.dccl.field) = {
  bool has_pcm() const;
  void clear_pcm();
  static const int kPcmFieldNumber = 32;
  ::google::protobuf::int32 pcm() const;
  void set_pcm(::google::protobuf::int32 value);
 
  // required .goby.acomms.micromodem.protobuf.ReceiveMode mode = 1;
  bool has_mode() const;
  void clear_mode();
  static const int kModeFieldNumber = 1;
  ::goby::acomms::micromodem::protobuf::ReceiveMode mode() const;
  void set_mode(::goby::acomms::micromodem::protobuf::ReceiveMode value);
 
  // required .goby.acomms.micromodem.protobuf.ClockMode clock_mode = 3;
  bool has_clock_mode() const;
  void clear_clock_mode();
  static const int kClockModeFieldNumber = 3;
  ::goby::acomms::micromodem::protobuf::ClockMode clock_mode() const;
  void set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
 
  // required .goby.acomms.micromodem.protobuf.PSKErrorCode psk_error_code = 16;
  bool has_psk_error_code() const;
  void clear_psk_error_code();
  static const int kPskErrorCodeFieldNumber = 16;
  ::goby::acomms::micromodem::protobuf::PSKErrorCode psk_error_code() const;
  void set_psk_error_code(::goby::acomms::micromodem::protobuf::PSKErrorCode value);
 
  // required .goby.acomms.micromodem.protobuf.PacketType packet_type = 17;
  bool has_packet_type() const;
  void clear_packet_type();
  static const int kPacketTypeFieldNumber = 17;
  ::goby::acomms::micromodem::protobuf::PacketType packet_type() const;
  void set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value);
 
  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:
  void set_has_mode();
  void clear_has_mode();
  void set_has_time();
  void clear_has_time();
  void set_has_clock_mode();
  void clear_has_clock_mode();
  void set_has_mfd_peak();
  void clear_has_mfd_peak();
  void set_has_mfd_power();
  void clear_has_mfd_power();
  void set_has_mfd_ratio();
  void clear_has_mfd_ratio();
  void set_has_spl();
  void clear_has_spl();
  void set_has_shf_agn();
  void clear_has_shf_agn();
  void set_has_shf_ainpshift();
  void clear_has_shf_ainpshift();
  void set_has_shf_ainshift();
  void clear_has_shf_ainshift();
  void set_has_shf_mfdshift();
  void clear_has_shf_mfdshift();
  void set_has_shf_p2bshift();
  void clear_has_shf_p2bshift();
  void set_has_rate();
  void clear_has_rate();
  void set_has_source();
  void clear_has_source();
  void set_has_dest();
  void clear_has_dest();
  void set_has_psk_error_code();
  void clear_has_psk_error_code();
  void set_has_packet_type();
  void clear_has_packet_type();
  void set_has_number_frames();
  void clear_has_number_frames();
  void set_has_number_bad_frames();
  void clear_has_number_bad_frames();
  void set_has_snr_rss();
  void clear_has_snr_rss();
  void set_has_snr_in();
  void clear_has_snr_in();
  void set_has_snr_out();
  void clear_has_snr_out();
  void set_has_snr_symbols();
  void clear_has_snr_symbols();
  void set_has_mse_equalizer();
  void clear_has_mse_equalizer();
  void set_has_data_quality_factor();
  void clear_has_data_quality_factor();
  void set_has_doppler();
  void clear_has_doppler();
  void set_has_stddev_noise();
  void clear_has_stddev_noise();
  void set_has_carrier_freq();
  void clear_has_carrier_freq();
  void set_has_bandwidth();
  void clear_has_bandwidth();
  void set_has_version();
  void clear_has_version();
  void set_has_date();
  void clear_has_date();
  void set_has_pcm();
  void clear_has_pcm();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr date_;
  ::google::protobuf::uint64 time_;
  ::google::protobuf::int32 mfd_peak_;
  ::google::protobuf::int32 mfd_power_;
  ::google::protobuf::int32 mfd_ratio_;
  ::google::protobuf::int32 spl_;
  ::google::protobuf::int32 shf_agn_;
  ::google::protobuf::int32 shf_ainpshift_;
  ::google::protobuf::int32 shf_ainshift_;
  ::google::protobuf::int32 shf_mfdshift_;
  ::google::protobuf::int32 shf_p2bshift_;
  ::google::protobuf::int32 rate_;
  ::google::protobuf::int32 source_;
  ::google::protobuf::int32 dest_;
  ::google::protobuf::int32 number_frames_;
  ::google::protobuf::int32 number_bad_frames_;
  ::google::protobuf::int32 snr_rss_;
  ::google::protobuf::int32 snr_in_;
  ::google::protobuf::int32 snr_out_;
  ::google::protobuf::int32 snr_symbols_;
  ::google::protobuf::int32 mse_equalizer_;
  ::google::protobuf::int32 data_quality_factor_;
  double doppler_;
  ::google::protobuf::int32 stddev_noise_;
  ::google::protobuf::int32 carrier_freq_;
  ::google::protobuf::int32 bandwidth_;
  ::google::protobuf::int32 version_;
  ::google::protobuf::int32 pcm_;
  int mode_;
  int clock_mode_;
  int psk_error_code_;
  int packet_type_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class TransmitStatistics : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.TransmitStatistics) */ {
 public:
  TransmitStatistics();
  virtual ~TransmitStatistics();
 
  TransmitStatistics(const TransmitStatistics& from);
 
  inline TransmitStatistics& operator=(const TransmitStatistics& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TransmitStatistics(TransmitStatistics&& from) noexcept
    : TransmitStatistics() {
    *this = ::std::move(from);
  }
 
  inline TransmitStatistics& operator=(TransmitStatistics&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const TransmitStatistics& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TransmitStatistics* internal_default_instance() {
    return reinterpret_cast<const TransmitStatistics*>(
               &_TransmitStatistics_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;
 
  void Swap(TransmitStatistics* other);
  friend void swap(TransmitStatistics& a, TransmitStatistics& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline TransmitStatistics* New() const final {
    return CreateMaybeMessage<TransmitStatistics>(NULL);
  }
 
  TransmitStatistics* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TransmitStatistics>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TransmitStatistics& from);
  void MergeFrom(const TransmitStatistics& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TransmitStatistics* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional string date = 1;
  bool has_date() const;
  void clear_date();
  static const int kDateFieldNumber = 1;
  const ::std::string& date() const;
  void set_date(const ::std::string& value);
  #if LANG_CXX11
  void set_date(::std::string&& value);
  #endif
  void set_date(const char* value);
  void set_date(const char* value, size_t size);
  ::std::string* mutable_date();
  ::std::string* release_date();
  void set_allocated_date(::std::string* date);
 
  // optional string time = 2;
  bool has_time() const;
  void clear_time();
  static const int kTimeFieldNumber = 2;
  const ::std::string& time() const;
  void set_time(const ::std::string& value);
  #if LANG_CXX11
  void set_time(::std::string&& value);
  #endif
  void set_time(const char* value);
  void set_time(const char* value, size_t size);
  ::std::string* mutable_time();
  ::std::string* release_time();
  void set_allocated_time(::std::string* time);
 
  // optional int32 probe_length = 5;
  bool has_probe_length() const;
  void clear_probe_length();
  static const int kProbeLengthFieldNumber = 5;
  ::google::protobuf::int32 probe_length() const;
  void set_probe_length(::google::protobuf::int32 value);
 
  // optional int32 bandwidth = 6;
  bool has_bandwidth() const;
  void clear_bandwidth();
  static const int kBandwidthFieldNumber = 6;
  ::google::protobuf::int32 bandwidth() const;
  void set_bandwidth(::google::protobuf::int32 value);
 
  // optional int32 carrier_freq = 7;
  bool has_carrier_freq() const;
  void clear_carrier_freq();
  static const int kCarrierFreqFieldNumber = 7;
  ::google::protobuf::int32 carrier_freq() const;
  void set_carrier_freq(::google::protobuf::int32 value);
 
  // optional int32 rate = 8;
  bool has_rate() const;
  void clear_rate();
  static const int kRateFieldNumber = 8;
  ::google::protobuf::int32 rate() const;
  void set_rate(::google::protobuf::int32 value);
 
  // optional int32 source = 9;
  bool has_source() const;
  void clear_source();
  static const int kSourceFieldNumber = 9;
  ::google::protobuf::int32 source() const;
  void set_source(::google::protobuf::int32 value);
 
  // optional int32 dest = 10;
  bool has_dest() const;
  void clear_dest();
  static const int kDestFieldNumber = 10;
  ::google::protobuf::int32 dest() const;
  void set_dest(::google::protobuf::int32 value);
 
  // optional bool ack_requested = 11;
  bool has_ack_requested() const;
  void clear_ack_requested();
  static const int kAckRequestedFieldNumber = 11;
  bool ack_requested() const;
  void set_ack_requested(bool value);
 
  // optional int32 number_frames_expected = 12;
  bool has_number_frames_expected() const;
  void clear_number_frames_expected();
  static const int kNumberFramesExpectedFieldNumber = 12;
  ::google::protobuf::int32 number_frames_expected() const;
  void set_number_frames_expected(::google::protobuf::int32 value);
 
  // optional int32 number_frames_sent = 13;
  bool has_number_frames_sent() const;
  void clear_number_frames_sent();
  static const int kNumberFramesSentFieldNumber = 13;
  ::google::protobuf::int32 number_frames_sent() const;
  void set_number_frames_sent(::google::protobuf::int32 value);
 
  // optional int32 number_bytes = 15;
  bool has_number_bytes() const;
  void clear_number_bytes();
  static const int kNumberBytesFieldNumber = 15;
  ::google::protobuf::int32 number_bytes() const;
  void set_number_bytes(::google::protobuf::int32 value);
 
  // optional int32 version = 100 [default = 0];
  bool has_version() const;
  void clear_version();
  static const int kVersionFieldNumber = 100;
  ::google::protobuf::int32 version() const;
  void set_version(::google::protobuf::int32 value);
 
  // optional .goby.acomms.micromodem.protobuf.PacketType packet_type = 14;
  bool has_packet_type() const;
  void clear_packet_type();
  static const int kPacketTypeFieldNumber = 14;
  ::goby::acomms::micromodem::protobuf::PacketType packet_type() const;
  void set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value);
 
  // optional .goby.acomms.micromodem.protobuf.ClockMode clock_mode = 3;
  bool has_clock_mode() const;
  void clear_clock_mode();
  static const int kClockModeFieldNumber = 3;
  ::goby::acomms::micromodem::protobuf::ClockMode clock_mode() const;
  void set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value);
 
  // optional .goby.acomms.micromodem.protobuf.TransmitMode mode = 4;
  bool has_mode() const;
  void clear_mode();
  static const int kModeFieldNumber = 4;
  ::goby::acomms::micromodem::protobuf::TransmitMode mode() const;
  void set_mode(::goby::acomms::micromodem::protobuf::TransmitMode value);
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.TransmitStatistics)
 private:
  void set_has_date();
  void clear_has_date();
  void set_has_time();
  void clear_has_time();
  void set_has_clock_mode();
  void clear_has_clock_mode();
  void set_has_mode();
  void clear_has_mode();
  void set_has_probe_length();
  void clear_has_probe_length();
  void set_has_bandwidth();
  void clear_has_bandwidth();
  void set_has_carrier_freq();
  void clear_has_carrier_freq();
  void set_has_rate();
  void clear_has_rate();
  void set_has_source();
  void clear_has_source();
  void set_has_dest();
  void clear_has_dest();
  void set_has_ack_requested();
  void clear_has_ack_requested();
  void set_has_number_frames_expected();
  void clear_has_number_frames_expected();
  void set_has_number_frames_sent();
  void clear_has_number_frames_sent();
  void set_has_packet_type();
  void clear_has_packet_type();
  void set_has_number_bytes();
  void clear_has_number_bytes();
  void set_has_version();
  void clear_has_version();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr date_;
  ::google::protobuf::internal::ArenaStringPtr time_;
  ::google::protobuf::int32 probe_length_;
  ::google::protobuf::int32 bandwidth_;
  ::google::protobuf::int32 carrier_freq_;
  ::google::protobuf::int32 rate_;
  ::google::protobuf::int32 source_;
  ::google::protobuf::int32 dest_;
  bool ack_requested_;
  ::google::protobuf::int32 number_frames_expected_;
  ::google::protobuf::int32 number_frames_sent_;
  ::google::protobuf::int32 number_bytes_;
  ::google::protobuf::int32 version_;
  int packet_type_;
  int clock_mode_;
  int mode_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class HardwareControl : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.HardwareControl) */ {
 public:
  HardwareControl();
  virtual ~HardwareControl();
 
  HardwareControl(const HardwareControl& from);
 
  inline HardwareControl& operator=(const HardwareControl& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  HardwareControl(HardwareControl&& from) noexcept
    : HardwareControl() {
    *this = ::std::move(from);
  }
 
  inline HardwareControl& operator=(HardwareControl&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const HardwareControl& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const HardwareControl* internal_default_instance() {
    return reinterpret_cast<const HardwareControl*>(
               &_HardwareControl_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;
 
  void Swap(HardwareControl* other);
  friend void swap(HardwareControl& a, HardwareControl& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline HardwareControl* New() const final {
    return CreateMaybeMessage<HardwareControl>(NULL);
  }
 
  HardwareControl* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<HardwareControl>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const HardwareControl& from);
  void MergeFrom(const HardwareControl& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HardwareControl* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required .goby.acomms.micromodem.protobuf.HardwareControlMode mode = 2;
  bool has_mode() const;
  void clear_mode();
  static const int kModeFieldNumber = 2;
  ::goby::acomms::micromodem::protobuf::HardwareControlMode mode() const;
  void set_mode(::goby::acomms::micromodem::protobuf::HardwareControlMode value);
 
  // optional .goby.acomms.micromodem.protobuf.HardwareControlArgument arg = 3 [default = MODE0_ARG];
  bool has_arg() const;
  void clear_arg();
  static const int kArgFieldNumber = 3;
  ::goby::acomms::micromodem::protobuf::HardwareControlArgument arg() const;
  void set_arg(::goby::acomms::micromodem::protobuf::HardwareControlArgument value);
 
  // required .goby.acomms.micromodem.protobuf.HardwareLine line = 1;
  bool has_line() const;
  void clear_line();
  static const int kLineFieldNumber = 1;
  ::goby::acomms::micromodem::protobuf::HardwareLine line() const;
  void set_line(::goby::acomms::micromodem::protobuf::HardwareLine value);
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.HardwareControl)
 private:
  void set_has_line();
  void clear_has_line();
  void set_has_mode();
  void clear_has_mode();
  void set_has_arg();
  void clear_has_arg();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  int mode_;
  int arg_;
  int line_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class HardwareControlCommand : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.HardwareControlCommand) */ {
 public:
  HardwareControlCommand();
  virtual ~HardwareControlCommand();
 
  HardwareControlCommand(const HardwareControlCommand& from);
 
  inline HardwareControlCommand& operator=(const HardwareControlCommand& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  HardwareControlCommand(HardwareControlCommand&& from) noexcept
    : HardwareControlCommand() {
    *this = ::std::move(from);
  }
 
  inline HardwareControlCommand& operator=(HardwareControlCommand&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const HardwareControlCommand& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const HardwareControlCommand* internal_default_instance() {
    return reinterpret_cast<const HardwareControlCommand*>(
               &_HardwareControlCommand_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;
 
  void Swap(HardwareControlCommand* other);
  friend void swap(HardwareControlCommand& a, HardwareControlCommand& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline HardwareControlCommand* New() const final {
    return CreateMaybeMessage<HardwareControlCommand>(NULL);
  }
 
  HardwareControlCommand* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<HardwareControlCommand>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const HardwareControlCommand& from);
  void MergeFrom(const HardwareControlCommand& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HardwareControlCommand* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .goby.acomms.micromodem.protobuf.HardwareControl control = 5;
  bool has_control() const;
  void clear_control();
  static const int kControlFieldNumber = 5;
  private:
  const ::goby::acomms::micromodem::protobuf::HardwareControl& _internal_control() const;
  public:
  const ::goby::acomms::micromodem::protobuf::HardwareControl& control() const;
  ::goby::acomms::micromodem::protobuf::HardwareControl* release_control();
  ::goby::acomms::micromodem::protobuf::HardwareControl* mutable_control();
  void set_allocated_control(::goby::acomms::micromodem::protobuf::HardwareControl* control);
 
  // required int32 command_src = 1 [(.dccl.field) = {
  bool has_command_src() const;
  void clear_command_src();
  static const int kCommandSrcFieldNumber = 1;
  ::google::protobuf::int32 command_src() const;
  void set_command_src(::google::protobuf::int32 value);
 
  // required int32 command_dest = 2 [(.dccl.field) = {
  bool has_command_dest() const;
  void clear_command_dest();
  static const int kCommandDestFieldNumber = 2;
  ::google::protobuf::int32 command_dest() const;
  void set_command_dest(::google::protobuf::int32 value);
 
  // optional uint64 time = 3 [(.dccl.field) = {
  bool has_time() const;
  void clear_time();
  static const int kTimeFieldNumber = 3;
  ::google::protobuf::uint64 time() const;
  void set_time(::google::protobuf::uint64 value);
 
  // optional int32 hw_ctl_dest = 4 [(.dccl.field) = {
  bool has_hw_ctl_dest() const;
  void clear_hw_ctl_dest();
  static const int kHwCtlDestFieldNumber = 4;
  ::google::protobuf::int32 hw_ctl_dest() const;
  void set_hw_ctl_dest(::google::protobuf::int32 value);
 
  enum DCCLParameters { DCCL_ID = 515,  DCCL_MAX_BYTES = 32 };
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.HardwareControlCommand)
 private:
  void set_has_command_src();
  void clear_has_command_src();
  void set_has_command_dest();
  void clear_has_command_dest();
  void set_has_time();
  void clear_has_time();
  void set_has_hw_ctl_dest();
  void clear_has_hw_ctl_dest();
  void set_has_control();
  void clear_has_control();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::goby::acomms::micromodem::protobuf::HardwareControl* control_;
  ::google::protobuf::int32 command_src_;
  ::google::protobuf::int32 command_dest_;
  ::google::protobuf::uint64 time_;
  ::google::protobuf::int32 hw_ctl_dest_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class Transmission : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.Transmission) */ {
 public:
  Transmission();
  virtual ~Transmission();
 
  Transmission(const Transmission& from);
 
  inline Transmission& operator=(const Transmission& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Transmission(Transmission&& from) noexcept
    : Transmission() {
    *this = ::std::move(from);
  }
 
  inline Transmission& operator=(Transmission&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const Transmission& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Transmission* internal_default_instance() {
    return reinterpret_cast<const Transmission*>(
               &_Transmission_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;
 
  void Swap(Transmission* other);
  friend void swap(Transmission& a, Transmission& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline Transmission* New() const final {
    return CreateMaybeMessage<Transmission>(NULL);
  }
 
  Transmission* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Transmission>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Transmission& from);
  void MergeFrom(const Transmission& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Transmission* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // repeated .goby.acomms.micromodem.protobuf.ReceiveStatistics receive_stat = 5 [(.goby.field) = {
  int receive_stat_size() const;
  void clear_receive_stat();
  static const int kReceiveStatFieldNumber = 5;
  ::goby::acomms::micromodem::protobuf::ReceiveStatistics* mutable_receive_stat(int index);
  ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::ReceiveStatistics >*
      mutable_receive_stat();
  const ::goby::acomms::micromodem::protobuf::ReceiveStatistics& receive_stat(int index) const;
  ::goby::acomms::micromodem::protobuf::ReceiveStatistics* add_receive_stat();
  const ::google::protobuf::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;
  void clear_transmit_stat();
  static const int kTransmitStatFieldNumber = 6;
  ::goby::acomms::micromodem::protobuf::TransmitStatistics* mutable_transmit_stat(int index);
  ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::TransmitStatistics >*
      mutable_transmit_stat();
  const ::goby::acomms::micromodem::protobuf::TransmitStatistics& transmit_stat(int index) const;
  ::goby::acomms::micromodem::protobuf::TransmitStatistics* add_transmit_stat();
  const ::google::protobuf::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;
  void clear_frame_with_bad_crc();
  static const int kFrameWithBadCrcFieldNumber = 7;
  ::google::protobuf::int32 frame_with_bad_crc(int index) const;
  void set_frame_with_bad_crc(int index, ::google::protobuf::int32 value);
  void add_frame_with_bad_crc(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      frame_with_bad_crc() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_frame_with_bad_crc();
 
  // optional .goby.acomms.micromodem.protobuf.NarrowBandLBLParams narrowband_lbl = 2 [(.dccl.field) = {
  bool has_narrowband_lbl() const;
  void clear_narrowband_lbl();
  static const int kNarrowbandLblFieldNumber = 2;
  private:
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& _internal_narrowband_lbl() const;
  public:
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& narrowband_lbl() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.REMUSLBLParams remus_lbl = 3 [(.dccl.field) = {
  bool has_remus_lbl() const;
  void clear_remus_lbl();
  static const int kRemusLblFieldNumber = 3;
  private:
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& _internal_remus_lbl() const;
  public:
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& remus_lbl() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.RangingReply ranging_reply = 4 [(.goby.field) = {
  bool has_ranging_reply() const;
  void clear_ranging_reply();
  static const int kRangingReplyFieldNumber = 4;
  private:
  const ::goby::acomms::micromodem::protobuf::RangingReply& _internal_ranging_reply() const;
  public:
  const ::goby::acomms::micromodem::protobuf::RangingReply& ranging_reply() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.HardwareControl hw_ctl = 8 [(.dccl.field) = {
  bool has_hw_ctl() const;
  void clear_hw_ctl();
  static const int kHwCtlFieldNumber = 8;
  private:
  const ::goby::acomms::micromodem::protobuf::HardwareControl& _internal_hw_ctl() const;
  public:
  const ::goby::acomms::micromodem::protobuf::HardwareControl& hw_ctl() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.GenericLBLParams generic_lbl = 9 [(.dccl.field) = {
  bool has_generic_lbl() const;
  void clear_generic_lbl();
  static const int kGenericLblFieldNumber = 9;
  private:
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams& _internal_generic_lbl() const;
  public:
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams& generic_lbl() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.FMSweepParams fm_sweep = 10 [(.dccl.field) = {
  bool has_fm_sweep() const;
  void clear_fm_sweep();
  static const int kFmSweepFieldNumber = 10;
  private:
  const ::goby::acomms::micromodem::protobuf::FMSweepParams& _internal_fm_sweep() const;
  public:
  const ::goby::acomms::micromodem::protobuf::FMSweepParams& fm_sweep() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.MSequenceParams m_sequence = 11 [(.dccl.field) = {
  bool has_m_sequence() const;
  void clear_m_sequence();
  static const int kMSequenceFieldNumber = 11;
  private:
  const ::goby::acomms::micromodem::protobuf::MSequenceParams& _internal_m_sequence() const;
  public:
  const ::goby::acomms::micromodem::protobuf::MSequenceParams& m_sequence() const;
  ::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);
 
  // optional .goby.acomms.micromodem.protobuf.TransmissionType type = 1 [default = BASE_TYPE, (.goby.field) = {
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 1;
  ::goby::acomms::micromodem::protobuf::TransmissionType type() const;
  void set_type(::goby::acomms::micromodem::protobuf::TransmissionType value);
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.Transmission)
 private:
  void set_has_type();
  void clear_has_type();
  void set_has_narrowband_lbl();
  void clear_has_narrowband_lbl();
  void set_has_remus_lbl();
  void clear_has_remus_lbl();
  void set_has_ranging_reply();
  void clear_has_ranging_reply();
  void set_has_hw_ctl();
  void clear_has_hw_ctl();
  void set_has_generic_lbl();
  void clear_has_generic_lbl();
  void set_has_fm_sweep();
  void clear_has_fm_sweep();
  void set_has_m_sequence();
  void clear_has_m_sequence();
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::ReceiveStatistics > receive_stat_;
  ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::TransmitStatistics > transmit_stat_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > 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_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class MMApplicationAck_AckPart : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart) */ {
 public:
  MMApplicationAck_AckPart();
  virtual ~MMApplicationAck_AckPart();
 
  MMApplicationAck_AckPart(const MMApplicationAck_AckPart& from);
 
  inline MMApplicationAck_AckPart& operator=(const MMApplicationAck_AckPart& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  MMApplicationAck_AckPart(MMApplicationAck_AckPart&& from) noexcept
    : MMApplicationAck_AckPart() {
    *this = ::std::move(from);
  }
 
  inline MMApplicationAck_AckPart& operator=(MMApplicationAck_AckPart&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const MMApplicationAck_AckPart& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MMApplicationAck_AckPart* internal_default_instance() {
    return reinterpret_cast<const MMApplicationAck_AckPart*>(
               &_MMApplicationAck_AckPart_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;
 
  void Swap(MMApplicationAck_AckPart* other);
  friend void swap(MMApplicationAck_AckPart& a, MMApplicationAck_AckPart& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline MMApplicationAck_AckPart* New() const final {
    return CreateMaybeMessage<MMApplicationAck_AckPart>(NULL);
  }
 
  MMApplicationAck_AckPart* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<MMApplicationAck_AckPart>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const MMApplicationAck_AckPart& from);
  void MergeFrom(const MMApplicationAck_AckPart& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MMApplicationAck_AckPart* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required int32 ack_dest = 1 [(.dccl.field) = {
  bool has_ack_dest() const;
  void clear_ack_dest();
  static const int kAckDestFieldNumber = 1;
  ::google::protobuf::int32 ack_dest() const;
  void set_ack_dest(::google::protobuf::int32 value);
 
  // required uint32 acked_frames = 2 [(.dccl.field) = {
  bool has_acked_frames() const;
  void clear_acked_frames();
  static const int kAckedFramesFieldNumber = 2;
  ::google::protobuf::uint32 acked_frames() const;
  void set_acked_frames(::google::protobuf::uint32 value);
 
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart)
 private:
  void set_has_ack_dest();
  void clear_has_ack_dest();
  void set_has_acked_frames();
  void clear_has_acked_frames();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 ack_dest_;
  ::google::protobuf::uint32 acked_frames_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class MMApplicationAck : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.acomms.micromodem.protobuf.MMApplicationAck) */ {
 public:
  MMApplicationAck();
  virtual ~MMApplicationAck();
 
  MMApplicationAck(const MMApplicationAck& from);
 
  inline MMApplicationAck& operator=(const MMApplicationAck& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  MMApplicationAck(MMApplicationAck&& from) noexcept
    : MMApplicationAck() {
    *this = ::std::move(from);
  }
 
  inline MMApplicationAck& operator=(MMApplicationAck&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const MMApplicationAck& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MMApplicationAck* internal_default_instance() {
    return reinterpret_cast<const MMApplicationAck*>(
               &_MMApplicationAck_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;
 
  void Swap(MMApplicationAck* other);
  friend void swap(MMApplicationAck& a, MMApplicationAck& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline MMApplicationAck* New() const final {
    return CreateMaybeMessage<MMApplicationAck>(NULL);
  }
 
  MMApplicationAck* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<MMApplicationAck>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const MMApplicationAck& from);
  void MergeFrom(const MMApplicationAck& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MMApplicationAck* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef MMApplicationAck_AckPart AckPart;
 
  // accessors -------------------------------------------------------
 
  // repeated .goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart part = 1 [(.dccl.field) = {
  int part_size() const;
  void clear_part();
  static const int kPartFieldNumber = 1;
  ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart* mutable_part(int index);
  ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart >*
      mutable_part();
  const ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart& part(int index) const;
  ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart* add_part();
  const ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart >&
      part() const;
 
  // required bool ack_requested = 3;
  bool has_ack_requested() const;
  void clear_ack_requested();
  static const int kAckRequestedFieldNumber = 3;
  bool ack_requested() const;
  void set_ack_requested(bool value);
 
  // required uint32 frame_start = 4 [(.dccl.field) = {
  bool has_frame_start() const;
  void clear_frame_start();
  static const int kFrameStartFieldNumber = 4;
  ::google::protobuf::uint32 frame_start() const;
  void set_frame_start(::google::protobuf::uint32 value);
 
  enum DCCLParameters { DCCL_ID = 10,  DCCL_MAX_BYTES = 32 };
  // @@protoc_insertion_point(class_scope:goby.acomms.micromodem.protobuf.MMApplicationAck)
 private:
  void set_has_ack_requested();
  void clear_has_ack_requested();
  void set_has_frame_start();
  void clear_has_frame_start();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart > part_;
  bool ack_requested_;
  ::google::protobuf::uint32 frame_start_;
  friend struct ::protobuf_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto::TableStruct;
};
// ===================================================================
 
static const int kConfigFieldNumber = 1000;
extern ::google::protobuf::internal::ExtensionIdentifier< ::goby::acomms::protobuf::DriverConfig,
    ::google::protobuf::internal::MessageTypeTraits< ::goby::acomms::micromodem::protobuf::Config >, 11, false >
  config;
static const int kTransmissionFieldNumber = 1000;
extern ::google::protobuf::internal::ExtensionIdentifier< ::goby::acomms::protobuf::ModemTransmission,
    ::google::protobuf::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::has_transmit_freq() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NarrowBandLBLParams::set_has_transmit_freq() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NarrowBandLBLParams::clear_has_transmit_freq() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NarrowBandLBLParams::clear_transmit_freq() {
  transmit_freq_ = 0u;
  clear_has_transmit_freq();
}
inline ::google::protobuf::uint32 NarrowBandLBLParams::transmit_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.transmit_freq)
  return transmit_freq_;
}
inline void NarrowBandLBLParams::set_transmit_freq(::google::protobuf::uint32 value) {
  set_has_transmit_freq();
  transmit_freq_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.transmit_freq)
}
 
// optional uint32 transmit_ping_ms = 2;
inline bool NarrowBandLBLParams::has_transmit_ping_ms() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NarrowBandLBLParams::set_has_transmit_ping_ms() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NarrowBandLBLParams::clear_has_transmit_ping_ms() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NarrowBandLBLParams::clear_transmit_ping_ms() {
  transmit_ping_ms_ = 0u;
  clear_has_transmit_ping_ms();
}
inline ::google::protobuf::uint32 NarrowBandLBLParams::transmit_ping_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.transmit_ping_ms)
  return transmit_ping_ms_;
}
inline void NarrowBandLBLParams::set_transmit_ping_ms(::google::protobuf::uint32 value) {
  set_has_transmit_ping_ms();
  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::receive_freq_size() const {
  return receive_freq_.size();
}
inline void NarrowBandLBLParams::clear_receive_freq() {
  receive_freq_.Clear();
}
inline ::google::protobuf::uint32 NarrowBandLBLParams::receive_freq(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_freq)
  return receive_freq_.Get(index);
}
inline void NarrowBandLBLParams::set_receive_freq(int index, ::google::protobuf::uint32 value) {
  receive_freq_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_freq)
}
inline void NarrowBandLBLParams::add_receive_freq(::google::protobuf::uint32 value) {
  receive_freq_.Add(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_freq)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
NarrowBandLBLParams::receive_freq() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_freq)
  return receive_freq_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
NarrowBandLBLParams::mutable_receive_freq() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_freq)
  return &receive_freq_;
}
 
// optional uint32 receive_ping_ms = 4;
inline bool NarrowBandLBLParams::has_receive_ping_ms() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NarrowBandLBLParams::set_has_receive_ping_ms() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NarrowBandLBLParams::clear_has_receive_ping_ms() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void NarrowBandLBLParams::clear_receive_ping_ms() {
  receive_ping_ms_ = 0u;
  clear_has_receive_ping_ms();
}
inline ::google::protobuf::uint32 NarrowBandLBLParams::receive_ping_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.receive_ping_ms)
  return receive_ping_ms_;
}
inline void NarrowBandLBLParams::set_receive_ping_ms(::google::protobuf::uint32 value) {
  set_has_receive_ping_ms();
  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::has_turnaround_ms() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NarrowBandLBLParams::set_has_turnaround_ms() {
  _has_bits_[0] |= 0x00000008u;
}
inline void NarrowBandLBLParams::clear_has_turnaround_ms() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void NarrowBandLBLParams::clear_turnaround_ms() {
  turnaround_ms_ = 0u;
  clear_has_turnaround_ms();
}
inline ::google::protobuf::uint32 NarrowBandLBLParams::turnaround_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.turnaround_ms)
  return turnaround_ms_;
}
inline void NarrowBandLBLParams::set_turnaround_ms(::google::protobuf::uint32 value) {
  set_has_turnaround_ms();
  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::has_transmit_flag() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void NarrowBandLBLParams::set_has_transmit_flag() {
  _has_bits_[0] |= 0x00000010u;
}
inline void NarrowBandLBLParams::clear_has_transmit_flag() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void NarrowBandLBLParams::clear_transmit_flag() {
  transmit_flag_ = true;
  clear_has_transmit_flag();
}
inline bool NarrowBandLBLParams::transmit_flag() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.transmit_flag)
  return transmit_flag_;
}
inline void NarrowBandLBLParams::set_transmit_flag(bool value) {
  set_has_transmit_flag();
  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::has_lbl_max_range() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void NarrowBandLBLParams::set_has_lbl_max_range() {
  _has_bits_[0] |= 0x00000020u;
}
inline void NarrowBandLBLParams::clear_has_lbl_max_range() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void NarrowBandLBLParams::clear_lbl_max_range() {
  lbl_max_range_ = 2000u;
  clear_has_lbl_max_range();
}
inline ::google::protobuf::uint32 NarrowBandLBLParams::lbl_max_range() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.NarrowBandLBLParams.lbl_max_range)
  return lbl_max_range_;
}
inline void NarrowBandLBLParams::set_lbl_max_range(::google::protobuf::uint32 value) {
  set_has_lbl_max_range();
  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::has_enable_beacons() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void REMUSLBLParams::set_has_enable_beacons() {
  _has_bits_[0] |= 0x00000002u;
}
inline void REMUSLBLParams::clear_has_enable_beacons() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void REMUSLBLParams::clear_enable_beacons() {
  enable_beacons_ = 15u;
  clear_has_enable_beacons();
}
inline ::google::protobuf::uint32 REMUSLBLParams::enable_beacons() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.REMUSLBLParams.enable_beacons)
  return enable_beacons_;
}
inline void REMUSLBLParams::set_enable_beacons(::google::protobuf::uint32 value) {
  set_has_enable_beacons();
  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::has_turnaround_ms() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void REMUSLBLParams::set_has_turnaround_ms() {
  _has_bits_[0] |= 0x00000004u;
}
inline void REMUSLBLParams::clear_has_turnaround_ms() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void REMUSLBLParams::clear_turnaround_ms() {
  turnaround_ms_ = 50u;
  clear_has_turnaround_ms();
}
inline ::google::protobuf::uint32 REMUSLBLParams::turnaround_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.REMUSLBLParams.turnaround_ms)
  return turnaround_ms_;
}
inline void REMUSLBLParams::set_turnaround_ms(::google::protobuf::uint32 value) {
  set_has_turnaround_ms();
  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::has_lbl_max_range() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void REMUSLBLParams::set_has_lbl_max_range() {
  _has_bits_[0] |= 0x00000001u;
}
inline void REMUSLBLParams::clear_has_lbl_max_range() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void REMUSLBLParams::clear_lbl_max_range() {
  lbl_max_range_ = 1000u;
  clear_has_lbl_max_range();
}
inline ::google::protobuf::uint32 REMUSLBLParams::lbl_max_range() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.REMUSLBLParams.lbl_max_range)
  return lbl_max_range_;
}
inline void REMUSLBLParams::set_lbl_max_range(::google::protobuf::uint32 value) {
  set_has_lbl_max_range();
  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::has_transmit_freq() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GenericLBLParams::set_has_transmit_freq() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GenericLBLParams::clear_has_transmit_freq() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GenericLBLParams::clear_transmit_freq() {
  transmit_freq_ = 0u;
  clear_has_transmit_freq();
}
inline ::google::protobuf::uint32 GenericLBLParams::transmit_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.transmit_freq)
  return transmit_freq_;
}
inline void GenericLBLParams::set_transmit_freq(::google::protobuf::uint32 value) {
  set_has_transmit_freq();
  transmit_freq_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.transmit_freq)
}
 
// optional uint32 n_bits = 2;
inline bool GenericLBLParams::has_n_bits() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GenericLBLParams::set_has_n_bits() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GenericLBLParams::clear_has_n_bits() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GenericLBLParams::clear_n_bits() {
  n_bits_ = 0u;
  clear_has_n_bits();
}
inline ::google::protobuf::uint32 GenericLBLParams::n_bits() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.n_bits)
  return n_bits_;
}
inline void GenericLBLParams::set_n_bits(::google::protobuf::uint32 value) {
  set_has_n_bits();
  n_bits_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.n_bits)
}
 
// optional uint64 transmit_seq_code = 3;
inline bool GenericLBLParams::has_transmit_seq_code() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GenericLBLParams::set_has_transmit_seq_code() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GenericLBLParams::clear_has_transmit_seq_code() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GenericLBLParams::clear_transmit_seq_code() {
  transmit_seq_code_ = GOOGLE_ULONGLONG(0);
  clear_has_transmit_seq_code();
}
inline ::google::protobuf::uint64 GenericLBLParams::transmit_seq_code() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.transmit_seq_code)
  return transmit_seq_code_;
}
inline void GenericLBLParams::set_transmit_seq_code(::google::protobuf::uint64 value) {
  set_has_transmit_seq_code();
  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::has_receive_freq() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GenericLBLParams::set_has_receive_freq() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GenericLBLParams::clear_has_receive_freq() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GenericLBLParams::clear_receive_freq() {
  receive_freq_ = 0u;
  clear_has_receive_freq();
}
inline ::google::protobuf::uint32 GenericLBLParams::receive_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_freq)
  return receive_freq_;
}
inline void GenericLBLParams::set_receive_freq(::google::protobuf::uint32 value) {
  set_has_receive_freq();
  receive_freq_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_freq)
}
 
// repeated uint64 receive_seq_code = 5;
inline int GenericLBLParams::receive_seq_code_size() const {
  return receive_seq_code_.size();
}
inline void GenericLBLParams::clear_receive_seq_code() {
  receive_seq_code_.Clear();
}
inline ::google::protobuf::uint64 GenericLBLParams::receive_seq_code(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_seq_code)
  return receive_seq_code_.Get(index);
}
inline void GenericLBLParams::set_receive_seq_code(int index, ::google::protobuf::uint64 value) {
  receive_seq_code_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_seq_code)
}
inline void GenericLBLParams::add_receive_seq_code(::google::protobuf::uint64 value) {
  receive_seq_code_.Add(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_seq_code)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
GenericLBLParams::receive_seq_code() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_seq_code)
  return receive_seq_code_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
GenericLBLParams::mutable_receive_seq_code() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.GenericLBLParams.receive_seq_code)
  return &receive_seq_code_;
}
 
// optional uint32 bandwidth = 6;
inline bool GenericLBLParams::has_bandwidth() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void GenericLBLParams::set_has_bandwidth() {
  _has_bits_[0] |= 0x00000010u;
}
inline void GenericLBLParams::clear_has_bandwidth() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void GenericLBLParams::clear_bandwidth() {
  bandwidth_ = 0u;
  clear_has_bandwidth();
}
inline ::google::protobuf::uint32 GenericLBLParams::bandwidth() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.bandwidth)
  return bandwidth_;
}
inline void GenericLBLParams::set_bandwidth(::google::protobuf::uint32 value) {
  set_has_bandwidth();
  bandwidth_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.GenericLBLParams.bandwidth)
}
 
// optional uint32 turnaround_ms = 7;
inline bool GenericLBLParams::has_turnaround_ms() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void GenericLBLParams::set_has_turnaround_ms() {
  _has_bits_[0] |= 0x00000020u;
}
inline void GenericLBLParams::clear_has_turnaround_ms() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void GenericLBLParams::clear_turnaround_ms() {
  turnaround_ms_ = 0u;
  clear_has_turnaround_ms();
}
inline ::google::protobuf::uint32 GenericLBLParams::turnaround_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.turnaround_ms)
  return turnaround_ms_;
}
inline void GenericLBLParams::set_turnaround_ms(::google::protobuf::uint32 value) {
  set_has_turnaround_ms();
  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::has_lbl_max_range() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void GenericLBLParams::set_has_lbl_max_range() {
  _has_bits_[0] |= 0x00000040u;
}
inline void GenericLBLParams::clear_has_lbl_max_range() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void GenericLBLParams::clear_lbl_max_range() {
  lbl_max_range_ = 2000u;
  clear_has_lbl_max_range();
}
inline ::google::protobuf::uint32 GenericLBLParams::lbl_max_range() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.GenericLBLParams.lbl_max_range)
  return lbl_max_range_;
}
inline void GenericLBLParams::set_lbl_max_range(::google::protobuf::uint32 value) {
  set_has_lbl_max_range();
  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::has_start_freq() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FMSweepParams::set_has_start_freq() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FMSweepParams::clear_has_start_freq() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FMSweepParams::clear_start_freq() {
  start_freq_ = 0;
  clear_has_start_freq();
}
inline double FMSweepParams::start_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.FMSweepParams.start_freq)
  return start_freq_;
}
inline void FMSweepParams::set_start_freq(double value) {
  set_has_start_freq();
  start_freq_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.FMSweepParams.start_freq)
}
 
// required double stop_freq = 2;
inline bool FMSweepParams::has_stop_freq() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FMSweepParams::set_has_stop_freq() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FMSweepParams::clear_has_stop_freq() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void FMSweepParams::clear_stop_freq() {
  stop_freq_ = 0;
  clear_has_stop_freq();
}
inline double FMSweepParams::stop_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.FMSweepParams.stop_freq)
  return stop_freq_;
}
inline void FMSweepParams::set_stop_freq(double value) {
  set_has_stop_freq();
  stop_freq_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.FMSweepParams.stop_freq)
}
 
// required double duration_ms = 3;
inline bool FMSweepParams::has_duration_ms() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void FMSweepParams::set_has_duration_ms() {
  _has_bits_[0] |= 0x00000004u;
}
inline void FMSweepParams::clear_has_duration_ms() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void FMSweepParams::clear_duration_ms() {
  duration_ms_ = 0;
  clear_has_duration_ms();
}
inline double FMSweepParams::duration_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.FMSweepParams.duration_ms)
  return duration_ms_;
}
inline void FMSweepParams::set_duration_ms(double value) {
  set_has_duration_ms();
  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::has_number_repetitions() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void FMSweepParams::set_has_number_repetitions() {
  _has_bits_[0] |= 0x00000008u;
}
inline void FMSweepParams::clear_has_number_repetitions() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void FMSweepParams::clear_number_repetitions() {
  number_repetitions_ = 1u;
  clear_has_number_repetitions();
}
inline ::google::protobuf::uint32 FMSweepParams::number_repetitions() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.FMSweepParams.number_repetitions)
  return number_repetitions_;
}
inline void FMSweepParams::set_number_repetitions(::google::protobuf::uint32 value) {
  set_has_number_repetitions();
  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::has_repetition_period_ms() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void FMSweepParams::set_has_repetition_period_ms() {
  _has_bits_[0] |= 0x00000010u;
}
inline void FMSweepParams::clear_has_repetition_period_ms() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void FMSweepParams::clear_repetition_period_ms() {
  repetition_period_ms_ = 1000;
  clear_has_repetition_period_ms();
}
inline double FMSweepParams::repetition_period_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.FMSweepParams.repetition_period_ms)
  return repetition_period_ms_;
}
inline void FMSweepParams::set_repetition_period_ms(double value) {
  set_has_repetition_period_ms();
  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::has_seqlen_bits() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MSequenceParams::set_has_seqlen_bits() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MSequenceParams::clear_has_seqlen_bits() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MSequenceParams::clear_seqlen_bits() {
  seqlen_bits_ = 0u;
  clear_has_seqlen_bits();
}
inline ::google::protobuf::uint32 MSequenceParams::seqlen_bits() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MSequenceParams.seqlen_bits)
  return seqlen_bits_;
}
inline void MSequenceParams::set_seqlen_bits(::google::protobuf::uint32 value) {
  set_has_seqlen_bits();
  seqlen_bits_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.MSequenceParams.seqlen_bits)
}
 
// required uint32 number_repetitions = 2;
inline bool MSequenceParams::has_number_repetitions() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MSequenceParams::set_has_number_repetitions() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MSequenceParams::clear_has_number_repetitions() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MSequenceParams::clear_number_repetitions() {
  number_repetitions_ = 0u;
  clear_has_number_repetitions();
}
inline ::google::protobuf::uint32 MSequenceParams::number_repetitions() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MSequenceParams.number_repetitions)
  return number_repetitions_;
}
inline void MSequenceParams::set_number_repetitions(::google::protobuf::uint32 value) {
  set_has_number_repetitions();
  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::has_carrier_cycles_per_chip() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MSequenceParams::set_has_carrier_cycles_per_chip() {
  _has_bits_[0] |= 0x00000004u;
}
inline void MSequenceParams::clear_has_carrier_cycles_per_chip() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void MSequenceParams::clear_carrier_cycles_per_chip() {
  carrier_cycles_per_chip_ = 0u;
  clear_has_carrier_cycles_per_chip();
}
inline ::google::protobuf::uint32 MSequenceParams::carrier_cycles_per_chip() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MSequenceParams.carrier_cycles_per_chip)
  return carrier_cycles_per_chip_;
}
inline void MSequenceParams::set_carrier_cycles_per_chip(::google::protobuf::uint32 value) {
  set_has_carrier_cycles_per_chip();
  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::has_carrier_freq() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MSequenceParams::set_has_carrier_freq() {
  _has_bits_[0] |= 0x00000008u;
}
inline void MSequenceParams::clear_has_carrier_freq() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void MSequenceParams::clear_carrier_freq() {
  carrier_freq_ = 0u;
  clear_has_carrier_freq();
}
inline ::google::protobuf::uint32 MSequenceParams::carrier_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MSequenceParams.carrier_freq)
  return carrier_freq_;
}
inline void MSequenceParams::set_carrier_freq(::google::protobuf::uint32 value) {
  set_has_carrier_freq();
  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::has_mm_major() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Config_Revision::set_has_mm_major() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Config_Revision::clear_has_mm_major() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Config_Revision::clear_mm_major() {
  mm_major_ = 0;
  clear_has_mm_major();
}
inline ::google::protobuf::int32 Config_Revision::mm_major() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.Revision.mm_major)
  return mm_major_;
}
inline void Config_Revision::set_mm_major(::google::protobuf::int32 value) {
  set_has_mm_major();
  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::has_mm_minor() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Config_Revision::set_has_mm_minor() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Config_Revision::clear_has_mm_minor() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Config_Revision::clear_mm_minor() {
  mm_minor_ = 0;
  clear_has_mm_minor();
}
inline ::google::protobuf::int32 Config_Revision::mm_minor() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.Revision.mm_minor)
  return mm_minor_;
}
inline void Config_Revision::set_mm_minor(::google::protobuf::int32 value) {
  set_has_mm_minor();
  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::has_mm_patch() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Config_Revision::set_has_mm_patch() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Config_Revision::clear_has_mm_patch() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Config_Revision::clear_mm_patch() {
  mm_patch_ = 0;
  clear_has_mm_patch();
}
inline ::google::protobuf::int32 Config_Revision::mm_patch() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.Revision.mm_patch)
  return mm_patch_;
}
inline void Config_Revision::set_mm_patch(::google::protobuf::int32 value) {
  set_has_mm_patch();
  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::has_reset_nvram() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Config::set_has_reset_nvram() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Config::clear_has_reset_nvram() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Config::clear_reset_nvram() {
  reset_nvram_ = false;
  clear_has_reset_nvram();
}
inline bool Config::reset_nvram() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.reset_nvram)
  return reset_nvram_;
}
inline void Config::set_reset_nvram(bool value) {
  set_has_reset_nvram();
  reset_nvram_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.reset_nvram)
}
 
// repeated string nvram_cfg = 2;
inline int Config::nvram_cfg_size() const {
  return nvram_cfg_.size();
}
inline void Config::clear_nvram_cfg() {
  nvram_cfg_.Clear();
}
inline const ::std::string& Config::nvram_cfg(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  return nvram_cfg_.Get(index);
}
inline ::std::string* Config::mutable_nvram_cfg(int index) {
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  return nvram_cfg_.Mutable(index);
}
inline void Config::set_nvram_cfg(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  nvram_cfg_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void Config::set_nvram_cfg(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  nvram_cfg_.Mutable(index)->assign(std::move(value));
}
#endif
inline void Config::set_nvram_cfg(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  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) {
  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::add_nvram_cfg() {
  // @@protoc_insertion_point(field_add_mutable:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  return nvram_cfg_.Add();
}
inline void Config::add_nvram_cfg(const ::std::string& value) {
  nvram_cfg_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
}
#if LANG_CXX11
inline void Config::add_nvram_cfg(::std::string&& value) {
  nvram_cfg_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
}
#endif
inline void Config::add_nvram_cfg(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  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) {
  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 ::google::protobuf::RepeatedPtrField< ::std::string>&
Config::nvram_cfg() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  return nvram_cfg_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
Config::mutable_nvram_cfg() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.Config.nvram_cfg)
  return &nvram_cfg_;
}
 
// optional uint32 hydroid_gateway_id = 3 [default = 0];
inline bool Config::has_hydroid_gateway_id() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Config::set_has_hydroid_gateway_id() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Config::clear_has_hydroid_gateway_id() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Config::clear_hydroid_gateway_id() {
  hydroid_gateway_id_ = 0u;
  clear_has_hydroid_gateway_id();
}
inline ::google::protobuf::uint32 Config::hydroid_gateway_id() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.hydroid_gateway_id)
  return hydroid_gateway_id_;
}
inline void Config::set_hydroid_gateway_id(::google::protobuf::uint32 value) {
  set_has_hydroid_gateway_id();
  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::has_narrowband_lbl() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Config::set_has_narrowband_lbl() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Config::clear_has_narrowband_lbl() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Config::clear_narrowband_lbl() {
  if (narrowband_lbl_ != NULL) narrowband_lbl_->Clear();
  clear_has_narrowband_lbl();
}
inline const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& Config::_internal_narrowband_lbl() const {
  return *narrowband_lbl_;
}
inline const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& Config::narrowband_lbl() const {
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* p = narrowband_lbl_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.narrowband_lbl)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams*>(
      &::goby::acomms::micromodem::protobuf::_NarrowBandLBLParams_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Config::release_narrowband_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.narrowband_lbl)
  clear_has_narrowband_lbl();
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* temp = narrowband_lbl_;
  narrowband_lbl_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Config::mutable_narrowband_lbl() {
  set_has_narrowband_lbl();
  if (narrowband_lbl_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::NarrowBandLBLParams>(GetArenaNoVirtual());
    narrowband_lbl_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.narrowband_lbl)
  return narrowband_lbl_;
}
inline void Config::set_allocated_narrowband_lbl(::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete narrowband_lbl_;
  }
  if (narrowband_lbl) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      narrowband_lbl = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, narrowband_lbl, submessage_arena);
    }
    set_has_narrowband_lbl();
  } else {
    clear_has_narrowband_lbl();
  }
  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::has_remus_lbl() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Config::set_has_remus_lbl() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Config::clear_has_remus_lbl() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Config::clear_remus_lbl() {
  if (remus_lbl_ != NULL) remus_lbl_->Clear();
  clear_has_remus_lbl();
}
inline const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& Config::_internal_remus_lbl() const {
  return *remus_lbl_;
}
inline const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& Config::remus_lbl() const {
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams* p = remus_lbl_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.remus_lbl)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::REMUSLBLParams*>(
      &::goby::acomms::micromodem::protobuf::_REMUSLBLParams_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Config::release_remus_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.remus_lbl)
  clear_has_remus_lbl();
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* temp = remus_lbl_;
  remus_lbl_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Config::mutable_remus_lbl() {
  set_has_remus_lbl();
  if (remus_lbl_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::REMUSLBLParams>(GetArenaNoVirtual());
    remus_lbl_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.remus_lbl)
  return remus_lbl_;
}
inline void Config::set_allocated_remus_lbl(::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete remus_lbl_;
  }
  if (remus_lbl) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      remus_lbl = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, remus_lbl, submessage_arena);
    }
    set_has_remus_lbl();
  } else {
    clear_has_remus_lbl();
  }
  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::has_keep_alive_seconds() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void Config::set_has_keep_alive_seconds() {
  _has_bits_[0] |= 0x00001000u;
}
inline void Config::clear_has_keep_alive_seconds() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void Config::clear_keep_alive_seconds() {
  keep_alive_seconds_ = 10;
  clear_has_keep_alive_seconds();
}
inline ::google::protobuf::int32 Config::keep_alive_seconds() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.keep_alive_seconds)
  return keep_alive_seconds_;
}
inline void Config::set_keep_alive_seconds(::google::protobuf::int32 value) {
  set_has_keep_alive_seconds();
  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::has_allowed_skew_ms() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void Config::set_has_allowed_skew_ms() {
  _has_bits_[0] |= 0x00002000u;
}
inline void Config::clear_has_allowed_skew_ms() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void Config::clear_allowed_skew_ms() {
  allowed_skew_ms_ = 1000;
  clear_has_allowed_skew_ms();
}
inline ::google::protobuf::int32 Config::allowed_skew_ms() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.allowed_skew_ms)
  return allowed_skew_ms_;
}
inline void Config::set_allowed_skew_ms(::google::protobuf::int32 value) {
  set_has_allowed_skew_ms();
  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::has_generic_lbl() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Config::set_has_generic_lbl() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Config::clear_has_generic_lbl() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Config::clear_generic_lbl() {
  if (generic_lbl_ != NULL) generic_lbl_->Clear();
  clear_has_generic_lbl();
}
inline const ::goby::acomms::micromodem::protobuf::GenericLBLParams& Config::_internal_generic_lbl() const {
  return *generic_lbl_;
}
inline const ::goby::acomms::micromodem::protobuf::GenericLBLParams& Config::generic_lbl() const {
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams* p = generic_lbl_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.generic_lbl)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::GenericLBLParams*>(
      &::goby::acomms::micromodem::protobuf::_GenericLBLParams_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Config::release_generic_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.generic_lbl)
  clear_has_generic_lbl();
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* temp = generic_lbl_;
  generic_lbl_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Config::mutable_generic_lbl() {
  set_has_generic_lbl();
  if (generic_lbl_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::GenericLBLParams>(GetArenaNoVirtual());
    generic_lbl_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.generic_lbl)
  return generic_lbl_;
}
inline void Config::set_allocated_generic_lbl(::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete generic_lbl_;
  }
  if (generic_lbl) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      generic_lbl = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, generic_lbl, submessage_arena);
    }
    set_has_generic_lbl();
  } else {
    clear_has_generic_lbl();
  }
  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::has_fm_sweep() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Config::set_has_fm_sweep() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Config::clear_has_fm_sweep() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Config::clear_fm_sweep() {
  if (fm_sweep_ != NULL) fm_sweep_->Clear();
  clear_has_fm_sweep();
}
inline const ::goby::acomms::micromodem::protobuf::FMSweepParams& Config::_internal_fm_sweep() const {
  return *fm_sweep_;
}
inline const ::goby::acomms::micromodem::protobuf::FMSweepParams& Config::fm_sweep() const {
  const ::goby::acomms::micromodem::protobuf::FMSweepParams* p = fm_sweep_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.fm_sweep)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::FMSweepParams*>(
      &::goby::acomms::micromodem::protobuf::_FMSweepParams_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Config::release_fm_sweep() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.fm_sweep)
  clear_has_fm_sweep();
  ::goby::acomms::micromodem::protobuf::FMSweepParams* temp = fm_sweep_;
  fm_sweep_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Config::mutable_fm_sweep() {
  set_has_fm_sweep();
  if (fm_sweep_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::FMSweepParams>(GetArenaNoVirtual());
    fm_sweep_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.fm_sweep)
  return fm_sweep_;
}
inline void Config::set_allocated_fm_sweep(::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete fm_sweep_;
  }
  if (fm_sweep) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      fm_sweep = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, fm_sweep, submessage_arena);
    }
    set_has_fm_sweep();
  } else {
    clear_has_fm_sweep();
  }
  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::has_m_sequence() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Config::set_has_m_sequence() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Config::clear_has_m_sequence() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Config::clear_m_sequence() {
  if (m_sequence_ != NULL) m_sequence_->Clear();
  clear_has_m_sequence();
}
inline const ::goby::acomms::micromodem::protobuf::MSequenceParams& Config::_internal_m_sequence() const {
  return *m_sequence_;
}
inline const ::goby::acomms::micromodem::protobuf::MSequenceParams& Config::m_sequence() const {
  const ::goby::acomms::micromodem::protobuf::MSequenceParams* p = m_sequence_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.m_sequence)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::MSequenceParams*>(
      &::goby::acomms::micromodem::protobuf::_MSequenceParams_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Config::release_m_sequence() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.m_sequence)
  clear_has_m_sequence();
  ::goby::acomms::micromodem::protobuf::MSequenceParams* temp = m_sequence_;
  m_sequence_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Config::mutable_m_sequence() {
  set_has_m_sequence();
  if (m_sequence_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::MSequenceParams>(GetArenaNoVirtual());
    m_sequence_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.m_sequence)
  return m_sequence_;
}
inline void Config::set_allocated_m_sequence(::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete m_sequence_;
  }
  if (m_sequence) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      m_sequence = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, m_sequence, submessage_arena);
    }
    set_has_m_sequence();
  } else {
    clear_has_m_sequence();
  }
  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::has_use_application_acks() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Config::set_has_use_application_acks() {
  _has_bits_[0] |= 0x00000100u;
}
inline void Config::clear_has_use_application_acks() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void Config::clear_use_application_acks() {
  use_application_acks_ = false;
  clear_has_use_application_acks();
}
inline bool Config::use_application_acks() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.use_application_acks)
  return use_application_acks_;
}
inline void Config::set_use_application_acks(bool value) {
  set_has_use_application_acks();
  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::additional_application_ack_modem_id_size() const {
  return additional_application_ack_modem_id_.size();
}
inline void Config::clear_additional_application_ack_modem_id() {
  additional_application_ack_modem_id_.Clear();
}
inline ::google::protobuf::uint32 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 additional_application_ack_modem_id_.Get(index);
}
inline void Config::set_additional_application_ack_modem_id(int index, ::google::protobuf::uint32 value) {
  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::add_additional_application_ack_modem_id(::google::protobuf::uint32 value) {
  additional_application_ack_modem_id_.Add(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Config.additional_application_ack_modem_id)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
Config::additional_application_ack_modem_id() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.Config.additional_application_ack_modem_id)
  return additional_application_ack_modem_id_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
Config::mutable_additional_application_ack_modem_id() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.Config.additional_application_ack_modem_id)
  return &additional_application_ack_modem_id_;
}
 
// optional bool query_cfg_on_startup = 22 [default = true];
inline bool Config::has_query_cfg_on_startup() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void Config::set_has_query_cfg_on_startup() {
  _has_bits_[0] |= 0x00000800u;
}
inline void Config::clear_has_query_cfg_on_startup() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void Config::clear_query_cfg_on_startup() {
  query_cfg_on_startup_ = true;
  clear_has_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 query_cfg_on_startup_;
}
inline void Config::set_query_cfg_on_startup(bool value) {
  set_has_query_cfg_on_startup();
  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::has_pad_partial_frames() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Config::set_has_pad_partial_frames() {
  _has_bits_[0] |= 0x00000200u;
}
inline void Config::clear_has_pad_partial_frames() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void Config::clear_pad_partial_frames() {
  pad_partial_frames_ = false;
  clear_has_pad_partial_frames();
}
inline bool Config::pad_partial_frames() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.pad_partial_frames)
  return pad_partial_frames_;
}
inline void Config::set_pad_partial_frames(bool value) {
  set_has_pad_partial_frames();
  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::has_revision() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Config::set_has_revision() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Config::clear_has_revision() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Config::clear_revision() {
  if (revision_ != NULL) revision_->Clear();
  clear_has_revision();
}
inline const ::goby::acomms::micromodem::protobuf::Config_Revision& Config::_internal_revision() const {
  return *revision_;
}
inline const ::goby::acomms::micromodem::protobuf::Config_Revision& Config::revision() const {
  const ::goby::acomms::micromodem::protobuf::Config_Revision* p = revision_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.revision)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::Config_Revision*>(
      &::goby::acomms::micromodem::protobuf::_Config_Revision_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::Config_Revision* Config::release_revision() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Config.revision)
  clear_has_revision();
  ::goby::acomms::micromodem::protobuf::Config_Revision* temp = revision_;
  revision_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::Config_Revision* Config::mutable_revision() {
  set_has_revision();
  if (revision_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::Config_Revision>(GetArenaNoVirtual());
    revision_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Config.revision)
  return revision_;
}
inline void Config::set_allocated_revision(::goby::acomms::micromodem::protobuf::Config_Revision* revision) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete revision_;
  }
  if (revision) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      revision = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, revision, submessage_arena);
    }
    set_has_revision();
  } else {
    clear_has_revision();
  }
  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::has_use_base64_fdp() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Config::set_has_use_base64_fdp() {
  _has_bits_[0] |= 0x00000400u;
}
inline void Config::clear_has_use_base64_fdp() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void Config::clear_use_base64_fdp() {
  use_base64_fdp_ = false;
  clear_has_use_base64_fdp();
}
inline bool Config::use_base64_fdp() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Config.use_base64_fdp)
  return use_base64_fdp_;
}
inline void Config::set_use_base64_fdp(bool value) {
  set_has_use_base64_fdp();
  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::one_way_travel_time_size() const {
  return one_way_travel_time_.size();
}
inline void RangingReply::clear_one_way_travel_time() {
  one_way_travel_time_.Clear();
}
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 one_way_travel_time_.Get(index);
}
inline void RangingReply::set_one_way_travel_time(int index, double value) {
  one_way_travel_time_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.RangingReply.one_way_travel_time)
}
inline void RangingReply::add_one_way_travel_time(double value) {
  one_way_travel_time_.Add(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.RangingReply.one_way_travel_time)
}
inline const ::google::protobuf::RepeatedField< double >&
RangingReply::one_way_travel_time() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.RangingReply.one_way_travel_time)
  return one_way_travel_time_;
}
inline ::google::protobuf::RepeatedField< double >*
RangingReply::mutable_one_way_travel_time() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.RangingReply.one_way_travel_time)
  return &one_way_travel_time_;
}
 
// optional .goby.acomms.micromodem.protobuf.RangingReply.OWTTAmbiguity ambiguity = 2 [default = OWTT_EXACT];
inline bool RangingReply::has_ambiguity() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void RangingReply::set_has_ambiguity() {
  _has_bits_[0] |= 0x00000008u;
}
inline void RangingReply::clear_has_ambiguity() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void RangingReply::clear_ambiguity() {
  ambiguity_ = 1;
  clear_has_ambiguity();
}
inline ::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity RangingReply::ambiguity() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.RangingReply.ambiguity)
  return static_cast< ::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity >(ambiguity_);
}
inline void RangingReply::set_ambiguity(::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity value) {
  assert(::goby::acomms::micromodem::protobuf::RangingReply_OWTTAmbiguity_IsValid(value));
  set_has_ambiguity();
  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::has_is_one_way_synchronous() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RangingReply::set_has_is_one_way_synchronous() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RangingReply::clear_has_is_one_way_synchronous() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RangingReply::clear_is_one_way_synchronous() {
  is_one_way_synchronous_ = false;
  clear_has_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 is_one_way_synchronous_;
}
inline void RangingReply::set_is_one_way_synchronous(bool value) {
  set_has_is_one_way_synchronous();
  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::has_receiver_clk_mode() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RangingReply::set_has_receiver_clk_mode() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RangingReply::clear_has_receiver_clk_mode() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RangingReply::clear_receiver_clk_mode() {
  receiver_clk_mode_ = 0;
  clear_has_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 static_cast< ::goby::acomms::micromodem::protobuf::ClockMode >(receiver_clk_mode_);
}
inline void RangingReply::set_receiver_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  assert(::goby::acomms::micromodem::protobuf::ClockMode_IsValid(value));
  set_has_receiver_clk_mode();
  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::has_sender_clk_mode() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RangingReply::set_has_sender_clk_mode() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RangingReply::clear_has_sender_clk_mode() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void RangingReply::clear_sender_clk_mode() {
  sender_clk_mode_ = 0;
  clear_has_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 static_cast< ::goby::acomms::micromodem::protobuf::ClockMode >(sender_clk_mode_);
}
inline void RangingReply::set_sender_clk_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  assert(::goby::acomms::micromodem::protobuf::ClockMode_IsValid(value));
  set_has_sender_clk_mode();
  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::has_mode() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void ReceiveStatistics::set_has_mode() {
  _has_bits_[0] |= 0x10000000u;
}
inline void ReceiveStatistics::clear_has_mode() {
  _has_bits_[0] &= ~0x10000000u;
}
inline void ReceiveStatistics::clear_mode() {
  mode_ = -1;
  clear_has_mode();
}
inline ::goby::acomms::micromodem::protobuf::ReceiveMode ReceiveStatistics::mode() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.mode)
  return static_cast< ::goby::acomms::micromodem::protobuf::ReceiveMode >(mode_);
}
inline void ReceiveStatistics::set_mode(::goby::acomms::micromodem::protobuf::ReceiveMode value) {
  assert(::goby::acomms::micromodem::protobuf::ReceiveMode_IsValid(value));
  set_has_mode();
  mode_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.mode)
}
 
// required uint64 time = 2 [(.dccl.field) = {
inline bool ReceiveStatistics::has_time() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReceiveStatistics::set_has_time() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ReceiveStatistics::clear_has_time() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ReceiveStatistics::clear_time() {
  time_ = GOOGLE_ULONGLONG(0);
  clear_has_time();
}
inline ::google::protobuf::uint64 ReceiveStatistics::time() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.time)
  return time_;
}
inline void ReceiveStatistics::set_time(::google::protobuf::uint64 value) {
  set_has_time();
  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::has_clock_mode() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void ReceiveStatistics::set_has_clock_mode() {
  _has_bits_[0] |= 0x20000000u;
}
inline void ReceiveStatistics::clear_has_clock_mode() {
  _has_bits_[0] &= ~0x20000000u;
}
inline void ReceiveStatistics::clear_clock_mode() {
  clock_mode_ = -1;
  clear_has_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 static_cast< ::goby::acomms::micromodem::protobuf::ClockMode >(clock_mode_);
}
inline void ReceiveStatistics::set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  assert(::goby::acomms::micromodem::protobuf::ClockMode_IsValid(value));
  set_has_clock_mode();
  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::has_mfd_peak() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ReceiveStatistics::set_has_mfd_peak() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ReceiveStatistics::clear_has_mfd_peak() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ReceiveStatistics::clear_mfd_peak() {
  mfd_peak_ = 0;
  clear_has_mfd_peak();
}
inline ::google::protobuf::int32 ReceiveStatistics::mfd_peak() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.mfd_peak)
  return mfd_peak_;
}
inline void ReceiveStatistics::set_mfd_peak(::google::protobuf::int32 value) {
  set_has_mfd_peak();
  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::has_mfd_power() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ReceiveStatistics::set_has_mfd_power() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ReceiveStatistics::clear_has_mfd_power() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ReceiveStatistics::clear_mfd_power() {
  mfd_power_ = 0;
  clear_has_mfd_power();
}
inline ::google::protobuf::int32 ReceiveStatistics::mfd_power() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.mfd_power)
  return mfd_power_;
}
inline void ReceiveStatistics::set_mfd_power(::google::protobuf::int32 value) {
  set_has_mfd_power();
  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::has_mfd_ratio() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ReceiveStatistics::set_has_mfd_ratio() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ReceiveStatistics::clear_has_mfd_ratio() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ReceiveStatistics::clear_mfd_ratio() {
  mfd_ratio_ = 0;
  clear_has_mfd_ratio();
}
inline ::google::protobuf::int32 ReceiveStatistics::mfd_ratio() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.mfd_ratio)
  return mfd_ratio_;
}
inline void ReceiveStatistics::set_mfd_ratio(::google::protobuf::int32 value) {
  set_has_mfd_ratio();
  mfd_ratio_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.mfd_ratio)
}
 
// optional int32 spl = 7 [(.dccl.field) = {
inline bool ReceiveStatistics::has_spl() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ReceiveStatistics::set_has_spl() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ReceiveStatistics::clear_has_spl() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ReceiveStatistics::clear_spl() {
  spl_ = 0;
  clear_has_spl();
}
inline ::google::protobuf::int32 ReceiveStatistics::spl() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.spl)
  return spl_;
}
inline void ReceiveStatistics::set_spl(::google::protobuf::int32 value) {
  set_has_spl();
  spl_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.spl)
}
 
// optional int32 shf_agn = 8 [(.dccl.field) = {
inline bool ReceiveStatistics::has_shf_agn() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ReceiveStatistics::set_has_shf_agn() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ReceiveStatistics::clear_has_shf_agn() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ReceiveStatistics::clear_shf_agn() {
  shf_agn_ = 0;
  clear_has_shf_agn();
}
inline ::google::protobuf::int32 ReceiveStatistics::shf_agn() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_agn)
  return shf_agn_;
}
inline void ReceiveStatistics::set_shf_agn(::google::protobuf::int32 value) {
  set_has_shf_agn();
  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::has_shf_ainpshift() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ReceiveStatistics::set_has_shf_ainpshift() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ReceiveStatistics::clear_has_shf_ainpshift() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ReceiveStatistics::clear_shf_ainpshift() {
  shf_ainpshift_ = 0;
  clear_has_shf_ainpshift();
}
inline ::google::protobuf::int32 ReceiveStatistics::shf_ainpshift() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_ainpshift)
  return shf_ainpshift_;
}
inline void ReceiveStatistics::set_shf_ainpshift(::google::protobuf::int32 value) {
  set_has_shf_ainpshift();
  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::has_shf_ainshift() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ReceiveStatistics::set_has_shf_ainshift() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ReceiveStatistics::clear_has_shf_ainshift() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ReceiveStatistics::clear_shf_ainshift() {
  shf_ainshift_ = 0;
  clear_has_shf_ainshift();
}
inline ::google::protobuf::int32 ReceiveStatistics::shf_ainshift() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_ainshift)
  return shf_ainshift_;
}
inline void ReceiveStatistics::set_shf_ainshift(::google::protobuf::int32 value) {
  set_has_shf_ainshift();
  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::has_shf_mfdshift() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ReceiveStatistics::set_has_shf_mfdshift() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ReceiveStatistics::clear_has_shf_mfdshift() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ReceiveStatistics::clear_shf_mfdshift() {
  shf_mfdshift_ = 0;
  clear_has_shf_mfdshift();
}
inline ::google::protobuf::int32 ReceiveStatistics::shf_mfdshift() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_mfdshift)
  return shf_mfdshift_;
}
inline void ReceiveStatistics::set_shf_mfdshift(::google::protobuf::int32 value) {
  set_has_shf_mfdshift();
  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::has_shf_p2bshift() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ReceiveStatistics::set_has_shf_p2bshift() {
  _has_bits_[0] |= 0x00000400u;
}
inline void ReceiveStatistics::clear_has_shf_p2bshift() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void ReceiveStatistics::clear_shf_p2bshift() {
  shf_p2bshift_ = 0;
  clear_has_shf_p2bshift();
}
inline ::google::protobuf::int32 ReceiveStatistics::shf_p2bshift() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_p2bshift)
  return shf_p2bshift_;
}
inline void ReceiveStatistics::set_shf_p2bshift(::google::protobuf::int32 value) {
  set_has_shf_p2bshift();
  shf_p2bshift_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.shf_p2bshift)
}
 
// required int32 rate = 13 [(.dccl.field) = {
inline bool ReceiveStatistics::has_rate() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ReceiveStatistics::set_has_rate() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ReceiveStatistics::clear_has_rate() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ReceiveStatistics::clear_rate() {
  rate_ = 0;
  clear_has_rate();
}
inline ::google::protobuf::int32 ReceiveStatistics::rate() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.rate)
  return rate_;
}
inline void ReceiveStatistics::set_rate(::google::protobuf::int32 value) {
  set_has_rate();
  rate_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.rate)
}
 
// required int32 source = 14 [(.dccl.field) = {
inline bool ReceiveStatistics::has_source() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ReceiveStatistics::set_has_source() {
  _has_bits_[0] |= 0x00001000u;
}
inline void ReceiveStatistics::clear_has_source() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void ReceiveStatistics::clear_source() {
  source_ = 0;
  clear_has_source();
}
inline ::google::protobuf::int32 ReceiveStatistics::source() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.source)
  return source_;
}
inline void ReceiveStatistics::set_source(::google::protobuf::int32 value) {
  set_has_source();
  source_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.source)
}
 
// required int32 dest = 15 [(.dccl.field) = {
inline bool ReceiveStatistics::has_dest() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ReceiveStatistics::set_has_dest() {
  _has_bits_[0] |= 0x00002000u;
}
inline void ReceiveStatistics::clear_has_dest() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void ReceiveStatistics::clear_dest() {
  dest_ = 0;
  clear_has_dest();
}
inline ::google::protobuf::int32 ReceiveStatistics::dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.dest)
  return dest_;
}
inline void ReceiveStatistics::set_dest(::google::protobuf::int32 value) {
  set_has_dest();
  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::has_psk_error_code() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void ReceiveStatistics::set_has_psk_error_code() {
  _has_bits_[0] |= 0x40000000u;
}
inline void ReceiveStatistics::clear_has_psk_error_code() {
  _has_bits_[0] &= ~0x40000000u;
}
inline void ReceiveStatistics::clear_psk_error_code() {
  psk_error_code_ = -1;
  clear_has_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 static_cast< ::goby::acomms::micromodem::protobuf::PSKErrorCode >(psk_error_code_);
}
inline void ReceiveStatistics::set_psk_error_code(::goby::acomms::micromodem::protobuf::PSKErrorCode value) {
  assert(::goby::acomms::micromodem::protobuf::PSKErrorCode_IsValid(value));
  set_has_psk_error_code();
  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::has_packet_type() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void ReceiveStatistics::set_has_packet_type() {
  _has_bits_[0] |= 0x80000000u;
}
inline void ReceiveStatistics::clear_has_packet_type() {
  _has_bits_[0] &= ~0x80000000u;
}
inline void ReceiveStatistics::clear_packet_type() {
  packet_type_ = -1;
  clear_has_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 static_cast< ::goby::acomms::micromodem::protobuf::PacketType >(packet_type_);
}
inline void ReceiveStatistics::set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value) {
  assert(::goby::acomms::micromodem::protobuf::PacketType_IsValid(value));
  set_has_packet_type();
  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::has_number_frames() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ReceiveStatistics::set_has_number_frames() {
  _has_bits_[0] |= 0x00004000u;
}
inline void ReceiveStatistics::clear_has_number_frames() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void ReceiveStatistics::clear_number_frames() {
  number_frames_ = 0;
  clear_has_number_frames();
}
inline ::google::protobuf::int32 ReceiveStatistics::number_frames() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.number_frames)
  return number_frames_;
}
inline void ReceiveStatistics::set_number_frames(::google::protobuf::int32 value) {
  set_has_number_frames();
  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::has_number_bad_frames() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void ReceiveStatistics::set_has_number_bad_frames() {
  _has_bits_[0] |= 0x00008000u;
}
inline void ReceiveStatistics::clear_has_number_bad_frames() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void ReceiveStatistics::clear_number_bad_frames() {
  number_bad_frames_ = 0;
  clear_has_number_bad_frames();
}
inline ::google::protobuf::int32 ReceiveStatistics::number_bad_frames() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.number_bad_frames)
  return number_bad_frames_;
}
inline void ReceiveStatistics::set_number_bad_frames(::google::protobuf::int32 value) {
  set_has_number_bad_frames();
  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::has_snr_rss() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void ReceiveStatistics::set_has_snr_rss() {
  _has_bits_[0] |= 0x00010000u;
}
inline void ReceiveStatistics::clear_has_snr_rss() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void ReceiveStatistics::clear_snr_rss() {
  snr_rss_ = 0;
  clear_has_snr_rss();
}
inline ::google::protobuf::int32 ReceiveStatistics::snr_rss() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_rss)
  return snr_rss_;
}
inline void ReceiveStatistics::set_snr_rss(::google::protobuf::int32 value) {
  set_has_snr_rss();
  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::has_snr_in() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void ReceiveStatistics::set_has_snr_in() {
  _has_bits_[0] |= 0x00020000u;
}
inline void ReceiveStatistics::clear_has_snr_in() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void ReceiveStatistics::clear_snr_in() {
  snr_in_ = 0;
  clear_has_snr_in();
}
inline ::google::protobuf::int32 ReceiveStatistics::snr_in() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_in)
  return snr_in_;
}
inline void ReceiveStatistics::set_snr_in(::google::protobuf::int32 value) {
  set_has_snr_in();
  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::has_snr_out() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void ReceiveStatistics::set_has_snr_out() {
  _has_bits_[0] |= 0x00040000u;
}
inline void ReceiveStatistics::clear_has_snr_out() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void ReceiveStatistics::clear_snr_out() {
  snr_out_ = 0;
  clear_has_snr_out();
}
inline ::google::protobuf::int32 ReceiveStatistics::snr_out() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_out)
  return snr_out_;
}
inline void ReceiveStatistics::set_snr_out(::google::protobuf::int32 value) {
  set_has_snr_out();
  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::has_snr_symbols() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void ReceiveStatistics::set_has_snr_symbols() {
  _has_bits_[0] |= 0x00080000u;
}
inline void ReceiveStatistics::clear_has_snr_symbols() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void ReceiveStatistics::clear_snr_symbols() {
  snr_symbols_ = 0;
  clear_has_snr_symbols();
}
inline ::google::protobuf::int32 ReceiveStatistics::snr_symbols() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.snr_symbols)
  return snr_symbols_;
}
inline void ReceiveStatistics::set_snr_symbols(::google::protobuf::int32 value) {
  set_has_snr_symbols();
  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::has_mse_equalizer() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void ReceiveStatistics::set_has_mse_equalizer() {
  _has_bits_[0] |= 0x00100000u;
}
inline void ReceiveStatistics::clear_has_mse_equalizer() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void ReceiveStatistics::clear_mse_equalizer() {
  mse_equalizer_ = 0;
  clear_has_mse_equalizer();
}
inline ::google::protobuf::int32 ReceiveStatistics::mse_equalizer() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.mse_equalizer)
  return mse_equalizer_;
}
inline void ReceiveStatistics::set_mse_equalizer(::google::protobuf::int32 value) {
  set_has_mse_equalizer();
  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::has_data_quality_factor() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void ReceiveStatistics::set_has_data_quality_factor() {
  _has_bits_[0] |= 0x00200000u;
}
inline void ReceiveStatistics::clear_has_data_quality_factor() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void ReceiveStatistics::clear_data_quality_factor() {
  data_quality_factor_ = 0;
  clear_has_data_quality_factor();
}
inline ::google::protobuf::int32 ReceiveStatistics::data_quality_factor() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.data_quality_factor)
  return data_quality_factor_;
}
inline void ReceiveStatistics::set_data_quality_factor(::google::protobuf::int32 value) {
  set_has_data_quality_factor();
  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::has_doppler() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void ReceiveStatistics::set_has_doppler() {
  _has_bits_[0] |= 0x00400000u;
}
inline void ReceiveStatistics::clear_has_doppler() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void ReceiveStatistics::clear_doppler() {
  doppler_ = 0;
  clear_has_doppler();
}
inline double ReceiveStatistics::doppler() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.doppler)
  return doppler_;
}
inline void ReceiveStatistics::set_doppler(double value) {
  set_has_doppler();
  doppler_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.doppler)
}
 
// required int32 stddev_noise = 27 [(.dccl.field) = {
inline bool ReceiveStatistics::has_stddev_noise() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void ReceiveStatistics::set_has_stddev_noise() {
  _has_bits_[0] |= 0x00800000u;
}
inline void ReceiveStatistics::clear_has_stddev_noise() {
  _has_bits_[0] &= ~0x00800000u;
}
inline void ReceiveStatistics::clear_stddev_noise() {
  stddev_noise_ = 0;
  clear_has_stddev_noise();
}
inline ::google::protobuf::int32 ReceiveStatistics::stddev_noise() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.stddev_noise)
  return stddev_noise_;
}
inline void ReceiveStatistics::set_stddev_noise(::google::protobuf::int32 value) {
  set_has_stddev_noise();
  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::has_carrier_freq() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void ReceiveStatistics::set_has_carrier_freq() {
  _has_bits_[0] |= 0x01000000u;
}
inline void ReceiveStatistics::clear_has_carrier_freq() {
  _has_bits_[0] &= ~0x01000000u;
}
inline void ReceiveStatistics::clear_carrier_freq() {
  carrier_freq_ = 0;
  clear_has_carrier_freq();
}
inline ::google::protobuf::int32 ReceiveStatistics::carrier_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.carrier_freq)
  return carrier_freq_;
}
inline void ReceiveStatistics::set_carrier_freq(::google::protobuf::int32 value) {
  set_has_carrier_freq();
  carrier_freq_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.carrier_freq)
}
 
// required int32 bandwidth = 29 [(.dccl.field) = {
inline bool ReceiveStatistics::has_bandwidth() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void ReceiveStatistics::set_has_bandwidth() {
  _has_bits_[0] |= 0x02000000u;
}
inline void ReceiveStatistics::clear_has_bandwidth() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void ReceiveStatistics::clear_bandwidth() {
  bandwidth_ = 0;
  clear_has_bandwidth();
}
inline ::google::protobuf::int32 ReceiveStatistics::bandwidth() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.bandwidth)
  return bandwidth_;
}
inline void ReceiveStatistics::set_bandwidth(::google::protobuf::int32 value) {
  set_has_bandwidth();
  bandwidth_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.bandwidth)
}
 
// optional int32 version = 30 [default = 0, (.dccl.field) = {
inline bool ReceiveStatistics::has_version() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void ReceiveStatistics::set_has_version() {
  _has_bits_[0] |= 0x04000000u;
}
inline void ReceiveStatistics::clear_has_version() {
  _has_bits_[0] &= ~0x04000000u;
}
inline void ReceiveStatistics::clear_version() {
  version_ = 0;
  clear_has_version();
}
inline ::google::protobuf::int32 ReceiveStatistics::version() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.version)
  return version_;
}
inline void ReceiveStatistics::set_version(::google::protobuf::int32 value) {
  set_has_version();
  version_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.version)
}
 
// optional string date = 31 [(.dccl.field) = {
inline bool ReceiveStatistics::has_date() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReceiveStatistics::set_has_date() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReceiveStatistics::clear_has_date() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReceiveStatistics::clear_date() {
  date_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_date();
}
inline const ::std::string& ReceiveStatistics::date() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
  return date_.GetNoArena();
}
inline void ReceiveStatistics::set_date(const ::std::string& value) {
  set_has_date();
  date_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
}
#if LANG_CXX11
inline void ReceiveStatistics::set_date(::std::string&& value) {
  set_has_date();
  date_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
}
#endif
inline void ReceiveStatistics::set_date(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_date();
  date_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
}
inline void ReceiveStatistics::set_date(const char* value, size_t size) {
  set_has_date();
  date_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
}
inline ::std::string* ReceiveStatistics::mutable_date() {
  set_has_date();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
  return date_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReceiveStatistics::release_date() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
  if (!has_date()) {
    return NULL;
  }
  clear_has_date();
  return date_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReceiveStatistics::set_allocated_date(::std::string* date) {
  if (date != NULL) {
    set_has_date();
  } else {
    clear_has_date();
  }
  date_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), date);
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.ReceiveStatistics.date)
}
 
// optional int32 pcm = 32 [(.dccl.field) = {
inline bool ReceiveStatistics::has_pcm() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void ReceiveStatistics::set_has_pcm() {
  _has_bits_[0] |= 0x08000000u;
}
inline void ReceiveStatistics::clear_has_pcm() {
  _has_bits_[0] &= ~0x08000000u;
}
inline void ReceiveStatistics::clear_pcm() {
  pcm_ = 0;
  clear_has_pcm();
}
inline ::google::protobuf::int32 ReceiveStatistics::pcm() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.ReceiveStatistics.pcm)
  return pcm_;
}
inline void ReceiveStatistics::set_pcm(::google::protobuf::int32 value) {
  set_has_pcm();
  pcm_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.ReceiveStatistics.pcm)
}
 
// -------------------------------------------------------------------
 
// TransmitStatistics
 
// optional string date = 1;
inline bool TransmitStatistics::has_date() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TransmitStatistics::set_has_date() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TransmitStatistics::clear_has_date() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TransmitStatistics::clear_date() {
  date_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_date();
}
inline const ::std::string& TransmitStatistics::date() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
  return date_.GetNoArena();
}
inline void TransmitStatistics::set_date(const ::std::string& value) {
  set_has_date();
  date_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
}
#if LANG_CXX11
inline void TransmitStatistics::set_date(::std::string&& value) {
  set_has_date();
  date_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
}
#endif
inline void TransmitStatistics::set_date(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_date();
  date_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
}
inline void TransmitStatistics::set_date(const char* value, size_t size) {
  set_has_date();
  date_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
}
inline ::std::string* TransmitStatistics::mutable_date() {
  set_has_date();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
  return date_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TransmitStatistics::release_date() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
  if (!has_date()) {
    return NULL;
  }
  clear_has_date();
  return date_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TransmitStatistics::set_allocated_date(::std::string* date) {
  if (date != NULL) {
    set_has_date();
  } else {
    clear_has_date();
  }
  date_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), date);
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.TransmitStatistics.date)
}
 
// optional string time = 2;
inline bool TransmitStatistics::has_time() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TransmitStatistics::set_has_time() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TransmitStatistics::clear_has_time() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TransmitStatistics::clear_time() {
  time_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_time();
}
inline const ::std::string& TransmitStatistics::time() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
  return time_.GetNoArena();
}
inline void TransmitStatistics::set_time(const ::std::string& value) {
  set_has_time();
  time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
}
#if LANG_CXX11
inline void TransmitStatistics::set_time(::std::string&& value) {
  set_has_time();
  time_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
}
#endif
inline void TransmitStatistics::set_time(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_time();
  time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
}
inline void TransmitStatistics::set_time(const char* value, size_t size) {
  set_has_time();
  time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
}
inline ::std::string* TransmitStatistics::mutable_time() {
  set_has_time();
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
  return time_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TransmitStatistics::release_time() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
  if (!has_time()) {
    return NULL;
  }
  clear_has_time();
  return time_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TransmitStatistics::set_allocated_time(::std::string* time) {
  if (time != NULL) {
    set_has_time();
  } else {
    clear_has_time();
  }
  time_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), time);
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.micromodem.protobuf.TransmitStatistics.time)
}
 
// optional .goby.acomms.micromodem.protobuf.ClockMode clock_mode = 3;
inline bool TransmitStatistics::has_clock_mode() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void TransmitStatistics::set_has_clock_mode() {
  _has_bits_[0] |= 0x00004000u;
}
inline void TransmitStatistics::clear_has_clock_mode() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void TransmitStatistics::clear_clock_mode() {
  clock_mode_ = -1;
  clear_has_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 static_cast< ::goby::acomms::micromodem::protobuf::ClockMode >(clock_mode_);
}
inline void TransmitStatistics::set_clock_mode(::goby::acomms::micromodem::protobuf::ClockMode value) {
  assert(::goby::acomms::micromodem::protobuf::ClockMode_IsValid(value));
  set_has_clock_mode();
  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::has_mode() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void TransmitStatistics::set_has_mode() {
  _has_bits_[0] |= 0x00008000u;
}
inline void TransmitStatistics::clear_has_mode() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void TransmitStatistics::clear_mode() {
  mode_ = -1;
  clear_has_mode();
}
inline ::goby::acomms::micromodem::protobuf::TransmitMode TransmitStatistics::mode() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.mode)
  return static_cast< ::goby::acomms::micromodem::protobuf::TransmitMode >(mode_);
}
inline void TransmitStatistics::set_mode(::goby::acomms::micromodem::protobuf::TransmitMode value) {
  assert(::goby::acomms::micromodem::protobuf::TransmitMode_IsValid(value));
  set_has_mode();
  mode_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.mode)
}
 
// optional int32 probe_length = 5;
inline bool TransmitStatistics::has_probe_length() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TransmitStatistics::set_has_probe_length() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TransmitStatistics::clear_has_probe_length() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TransmitStatistics::clear_probe_length() {
  probe_length_ = 0;
  clear_has_probe_length();
}
inline ::google::protobuf::int32 TransmitStatistics::probe_length() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.probe_length)
  return probe_length_;
}
inline void TransmitStatistics::set_probe_length(::google::protobuf::int32 value) {
  set_has_probe_length();
  probe_length_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.probe_length)
}
 
// optional int32 bandwidth = 6;
inline bool TransmitStatistics::has_bandwidth() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TransmitStatistics::set_has_bandwidth() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TransmitStatistics::clear_has_bandwidth() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TransmitStatistics::clear_bandwidth() {
  bandwidth_ = 0;
  clear_has_bandwidth();
}
inline ::google::protobuf::int32 TransmitStatistics::bandwidth() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.bandwidth)
  return bandwidth_;
}
inline void TransmitStatistics::set_bandwidth(::google::protobuf::int32 value) {
  set_has_bandwidth();
  bandwidth_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.bandwidth)
}
 
// optional int32 carrier_freq = 7;
inline bool TransmitStatistics::has_carrier_freq() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TransmitStatistics::set_has_carrier_freq() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TransmitStatistics::clear_has_carrier_freq() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TransmitStatistics::clear_carrier_freq() {
  carrier_freq_ = 0;
  clear_has_carrier_freq();
}
inline ::google::protobuf::int32 TransmitStatistics::carrier_freq() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.carrier_freq)
  return carrier_freq_;
}
inline void TransmitStatistics::set_carrier_freq(::google::protobuf::int32 value) {
  set_has_carrier_freq();
  carrier_freq_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.carrier_freq)
}
 
// optional int32 rate = 8;
inline bool TransmitStatistics::has_rate() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TransmitStatistics::set_has_rate() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TransmitStatistics::clear_has_rate() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TransmitStatistics::clear_rate() {
  rate_ = 0;
  clear_has_rate();
}
inline ::google::protobuf::int32 TransmitStatistics::rate() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.rate)
  return rate_;
}
inline void TransmitStatistics::set_rate(::google::protobuf::int32 value) {
  set_has_rate();
  rate_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.rate)
}
 
// optional int32 source = 9;
inline bool TransmitStatistics::has_source() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TransmitStatistics::set_has_source() {
  _has_bits_[0] |= 0x00000040u;
}
inline void TransmitStatistics::clear_has_source() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void TransmitStatistics::clear_source() {
  source_ = 0;
  clear_has_source();
}
inline ::google::protobuf::int32 TransmitStatistics::source() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.source)
  return source_;
}
inline void TransmitStatistics::set_source(::google::protobuf::int32 value) {
  set_has_source();
  source_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.source)
}
 
// optional int32 dest = 10;
inline bool TransmitStatistics::has_dest() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void TransmitStatistics::set_has_dest() {
  _has_bits_[0] |= 0x00000080u;
}
inline void TransmitStatistics::clear_has_dest() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void TransmitStatistics::clear_dest() {
  dest_ = 0;
  clear_has_dest();
}
inline ::google::protobuf::int32 TransmitStatistics::dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.dest)
  return dest_;
}
inline void TransmitStatistics::set_dest(::google::protobuf::int32 value) {
  set_has_dest();
  dest_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.dest)
}
 
// optional bool ack_requested = 11;
inline bool TransmitStatistics::has_ack_requested() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void TransmitStatistics::set_has_ack_requested() {
  _has_bits_[0] |= 0x00000100u;
}
inline void TransmitStatistics::clear_has_ack_requested() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void TransmitStatistics::clear_ack_requested() {
  ack_requested_ = false;
  clear_has_ack_requested();
}
inline bool TransmitStatistics::ack_requested() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.ack_requested)
  return ack_requested_;
}
inline void TransmitStatistics::set_ack_requested(bool value) {
  set_has_ack_requested();
  ack_requested_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.ack_requested)
}
 
// optional int32 number_frames_expected = 12;
inline bool TransmitStatistics::has_number_frames_expected() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void TransmitStatistics::set_has_number_frames_expected() {
  _has_bits_[0] |= 0x00000200u;
}
inline void TransmitStatistics::clear_has_number_frames_expected() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void TransmitStatistics::clear_number_frames_expected() {
  number_frames_expected_ = 0;
  clear_has_number_frames_expected();
}
inline ::google::protobuf::int32 TransmitStatistics::number_frames_expected() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.number_frames_expected)
  return number_frames_expected_;
}
inline void TransmitStatistics::set_number_frames_expected(::google::protobuf::int32 value) {
  set_has_number_frames_expected();
  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::has_number_frames_sent() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void TransmitStatistics::set_has_number_frames_sent() {
  _has_bits_[0] |= 0x00000400u;
}
inline void TransmitStatistics::clear_has_number_frames_sent() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void TransmitStatistics::clear_number_frames_sent() {
  number_frames_sent_ = 0;
  clear_has_number_frames_sent();
}
inline ::google::protobuf::int32 TransmitStatistics::number_frames_sent() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.number_frames_sent)
  return number_frames_sent_;
}
inline void TransmitStatistics::set_number_frames_sent(::google::protobuf::int32 value) {
  set_has_number_frames_sent();
  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::has_packet_type() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void TransmitStatistics::set_has_packet_type() {
  _has_bits_[0] |= 0x00002000u;
}
inline void TransmitStatistics::clear_has_packet_type() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void TransmitStatistics::clear_packet_type() {
  packet_type_ = -1;
  clear_has_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 static_cast< ::goby::acomms::micromodem::protobuf::PacketType >(packet_type_);
}
inline void TransmitStatistics::set_packet_type(::goby::acomms::micromodem::protobuf::PacketType value) {
  assert(::goby::acomms::micromodem::protobuf::PacketType_IsValid(value));
  set_has_packet_type();
  packet_type_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.packet_type)
}
 
// optional int32 number_bytes = 15;
inline bool TransmitStatistics::has_number_bytes() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void TransmitStatistics::set_has_number_bytes() {
  _has_bits_[0] |= 0x00000800u;
}
inline void TransmitStatistics::clear_has_number_bytes() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void TransmitStatistics::clear_number_bytes() {
  number_bytes_ = 0;
  clear_has_number_bytes();
}
inline ::google::protobuf::int32 TransmitStatistics::number_bytes() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.number_bytes)
  return number_bytes_;
}
inline void TransmitStatistics::set_number_bytes(::google::protobuf::int32 value) {
  set_has_number_bytes();
  number_bytes_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.TransmitStatistics.number_bytes)
}
 
// optional int32 version = 100 [default = 0];
inline bool TransmitStatistics::has_version() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void TransmitStatistics::set_has_version() {
  _has_bits_[0] |= 0x00001000u;
}
inline void TransmitStatistics::clear_has_version() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void TransmitStatistics::clear_version() {
  version_ = 0;
  clear_has_version();
}
inline ::google::protobuf::int32 TransmitStatistics::version() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.TransmitStatistics.version)
  return version_;
}
inline void TransmitStatistics::set_version(::google::protobuf::int32 value) {
  set_has_version();
  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::has_line() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void HardwareControl::set_has_line() {
  _has_bits_[0] |= 0x00000004u;
}
inline void HardwareControl::clear_has_line() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void HardwareControl::clear_line() {
  line_ = 5;
  clear_has_line();
}
inline ::goby::acomms::micromodem::protobuf::HardwareLine HardwareControl::line() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControl.line)
  return static_cast< ::goby::acomms::micromodem::protobuf::HardwareLine >(line_);
}
inline void HardwareControl::set_line(::goby::acomms::micromodem::protobuf::HardwareLine value) {
  assert(::goby::acomms::micromodem::protobuf::HardwareLine_IsValid(value));
  set_has_line();
  line_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.HardwareControl.line)
}
 
// required .goby.acomms.micromodem.protobuf.HardwareControlMode mode = 2;
inline bool HardwareControl::has_mode() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HardwareControl::set_has_mode() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HardwareControl::clear_has_mode() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HardwareControl::clear_mode() {
  mode_ = 0;
  clear_has_mode();
}
inline ::goby::acomms::micromodem::protobuf::HardwareControlMode HardwareControl::mode() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControl.mode)
  return static_cast< ::goby::acomms::micromodem::protobuf::HardwareControlMode >(mode_);
}
inline void HardwareControl::set_mode(::goby::acomms::micromodem::protobuf::HardwareControlMode value) {
  assert(::goby::acomms::micromodem::protobuf::HardwareControlMode_IsValid(value));
  set_has_mode();
  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::has_arg() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HardwareControl::set_has_arg() {
  _has_bits_[0] |= 0x00000002u;
}
inline void HardwareControl::clear_has_arg() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void HardwareControl::clear_arg() {
  arg_ = 0;
  clear_has_arg();
}
inline ::goby::acomms::micromodem::protobuf::HardwareControlArgument HardwareControl::arg() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControl.arg)
  return static_cast< ::goby::acomms::micromodem::protobuf::HardwareControlArgument >(arg_);
}
inline void HardwareControl::set_arg(::goby::acomms::micromodem::protobuf::HardwareControlArgument value) {
  assert(::goby::acomms::micromodem::protobuf::HardwareControlArgument_IsValid(value));
  set_has_arg();
  arg_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.HardwareControl.arg)
}
 
// -------------------------------------------------------------------
 
// HardwareControlCommand
 
// required int32 command_src = 1 [(.dccl.field) = {
inline bool HardwareControlCommand::has_command_src() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HardwareControlCommand::set_has_command_src() {
  _has_bits_[0] |= 0x00000002u;
}
inline void HardwareControlCommand::clear_has_command_src() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void HardwareControlCommand::clear_command_src() {
  command_src_ = 0;
  clear_has_command_src();
}
inline ::google::protobuf::int32 HardwareControlCommand::command_src() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControlCommand.command_src)
  return command_src_;
}
inline void HardwareControlCommand::set_command_src(::google::protobuf::int32 value) {
  set_has_command_src();
  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::has_command_dest() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void HardwareControlCommand::set_has_command_dest() {
  _has_bits_[0] |= 0x00000004u;
}
inline void HardwareControlCommand::clear_has_command_dest() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void HardwareControlCommand::clear_command_dest() {
  command_dest_ = 0;
  clear_has_command_dest();
}
inline ::google::protobuf::int32 HardwareControlCommand::command_dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControlCommand.command_dest)
  return command_dest_;
}
inline void HardwareControlCommand::set_command_dest(::google::protobuf::int32 value) {
  set_has_command_dest();
  command_dest_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.HardwareControlCommand.command_dest)
}
 
// optional uint64 time = 3 [(.dccl.field) = {
inline bool HardwareControlCommand::has_time() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void HardwareControlCommand::set_has_time() {
  _has_bits_[0] |= 0x00000008u;
}
inline void HardwareControlCommand::clear_has_time() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void HardwareControlCommand::clear_time() {
  time_ = GOOGLE_ULONGLONG(0);
  clear_has_time();
}
inline ::google::protobuf::uint64 HardwareControlCommand::time() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControlCommand.time)
  return time_;
}
inline void HardwareControlCommand::set_time(::google::protobuf::uint64 value) {
  set_has_time();
  time_ = value;
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.HardwareControlCommand.time)
}
 
// optional int32 hw_ctl_dest = 4 [(.dccl.field) = {
inline bool HardwareControlCommand::has_hw_ctl_dest() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void HardwareControlCommand::set_has_hw_ctl_dest() {
  _has_bits_[0] |= 0x00000010u;
}
inline void HardwareControlCommand::clear_has_hw_ctl_dest() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void HardwareControlCommand::clear_hw_ctl_dest() {
  hw_ctl_dest_ = 0;
  clear_has_hw_ctl_dest();
}
inline ::google::protobuf::int32 HardwareControlCommand::hw_ctl_dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControlCommand.hw_ctl_dest)
  return hw_ctl_dest_;
}
inline void HardwareControlCommand::set_hw_ctl_dest(::google::protobuf::int32 value) {
  set_has_hw_ctl_dest();
  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::has_control() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HardwareControlCommand::set_has_control() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HardwareControlCommand::clear_has_control() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HardwareControlCommand::clear_control() {
  if (control_ != NULL) control_->Clear();
  clear_has_control();
}
inline const ::goby::acomms::micromodem::protobuf::HardwareControl& HardwareControlCommand::_internal_control() const {
  return *control_;
}
inline const ::goby::acomms::micromodem::protobuf::HardwareControl& HardwareControlCommand::control() const {
  const ::goby::acomms::micromodem::protobuf::HardwareControl* p = control_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.HardwareControlCommand.control)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::HardwareControl*>(
      &::goby::acomms::micromodem::protobuf::_HardwareControl_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* HardwareControlCommand::release_control() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.HardwareControlCommand.control)
  clear_has_control();
  ::goby::acomms::micromodem::protobuf::HardwareControl* temp = control_;
  control_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* HardwareControlCommand::mutable_control() {
  set_has_control();
  if (control_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::HardwareControl>(GetArenaNoVirtual());
    control_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.HardwareControlCommand.control)
  return control_;
}
inline void HardwareControlCommand::set_allocated_control(::goby::acomms::micromodem::protobuf::HardwareControl* control) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete control_;
  }
  if (control) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      control = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, control, submessage_arena);
    }
    set_has_control();
  } else {
    clear_has_control();
  }
  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::has_type() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Transmission::set_has_type() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Transmission::clear_has_type() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Transmission::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::goby::acomms::micromodem::protobuf::TransmissionType Transmission::type() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.type)
  return static_cast< ::goby::acomms::micromodem::protobuf::TransmissionType >(type_);
}
inline void Transmission::set_type(::goby::acomms::micromodem::protobuf::TransmissionType value) {
  assert(::goby::acomms::micromodem::protobuf::TransmissionType_IsValid(value));
  set_has_type();
  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::has_narrowband_lbl() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Transmission::set_has_narrowband_lbl() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Transmission::clear_has_narrowband_lbl() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Transmission::clear_narrowband_lbl() {
  if (narrowband_lbl_ != NULL) narrowband_lbl_->Clear();
  clear_has_narrowband_lbl();
}
inline const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& Transmission::_internal_narrowband_lbl() const {
  return *narrowband_lbl_;
}
inline const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams& Transmission::narrowband_lbl() const {
  const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* p = narrowband_lbl_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.narrowband_lbl)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams*>(
      &::goby::acomms::micromodem::protobuf::_NarrowBandLBLParams_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Transmission::release_narrowband_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.narrowband_lbl)
  clear_has_narrowband_lbl();
  ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* temp = narrowband_lbl_;
  narrowband_lbl_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* Transmission::mutable_narrowband_lbl() {
  set_has_narrowband_lbl();
  if (narrowband_lbl_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::NarrowBandLBLParams>(GetArenaNoVirtual());
    narrowband_lbl_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.narrowband_lbl)
  return narrowband_lbl_;
}
inline void Transmission::set_allocated_narrowband_lbl(::goby::acomms::micromodem::protobuf::NarrowBandLBLParams* narrowband_lbl) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete narrowband_lbl_;
  }
  if (narrowband_lbl) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      narrowband_lbl = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, narrowband_lbl, submessage_arena);
    }
    set_has_narrowband_lbl();
  } else {
    clear_has_narrowband_lbl();
  }
  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::has_remus_lbl() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Transmission::set_has_remus_lbl() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Transmission::clear_has_remus_lbl() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Transmission::clear_remus_lbl() {
  if (remus_lbl_ != NULL) remus_lbl_->Clear();
  clear_has_remus_lbl();
}
inline const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& Transmission::_internal_remus_lbl() const {
  return *remus_lbl_;
}
inline const ::goby::acomms::micromodem::protobuf::REMUSLBLParams& Transmission::remus_lbl() const {
  const ::goby::acomms::micromodem::protobuf::REMUSLBLParams* p = remus_lbl_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.remus_lbl)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::REMUSLBLParams*>(
      &::goby::acomms::micromodem::protobuf::_REMUSLBLParams_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Transmission::release_remus_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.remus_lbl)
  clear_has_remus_lbl();
  ::goby::acomms::micromodem::protobuf::REMUSLBLParams* temp = remus_lbl_;
  remus_lbl_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::REMUSLBLParams* Transmission::mutable_remus_lbl() {
  set_has_remus_lbl();
  if (remus_lbl_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::REMUSLBLParams>(GetArenaNoVirtual());
    remus_lbl_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.remus_lbl)
  return remus_lbl_;
}
inline void Transmission::set_allocated_remus_lbl(::goby::acomms::micromodem::protobuf::REMUSLBLParams* remus_lbl) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete remus_lbl_;
  }
  if (remus_lbl) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      remus_lbl = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, remus_lbl, submessage_arena);
    }
    set_has_remus_lbl();
  } else {
    clear_has_remus_lbl();
  }
  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::has_ranging_reply() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Transmission::set_has_ranging_reply() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Transmission::clear_has_ranging_reply() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Transmission::clear_ranging_reply() {
  if (ranging_reply_ != NULL) ranging_reply_->Clear();
  clear_has_ranging_reply();
}
inline const ::goby::acomms::micromodem::protobuf::RangingReply& Transmission::_internal_ranging_reply() const {
  return *ranging_reply_;
}
inline const ::goby::acomms::micromodem::protobuf::RangingReply& Transmission::ranging_reply() const {
  const ::goby::acomms::micromodem::protobuf::RangingReply* p = ranging_reply_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.ranging_reply)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::RangingReply*>(
      &::goby::acomms::micromodem::protobuf::_RangingReply_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::RangingReply* Transmission::release_ranging_reply() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.ranging_reply)
  clear_has_ranging_reply();
  ::goby::acomms::micromodem::protobuf::RangingReply* temp = ranging_reply_;
  ranging_reply_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::RangingReply* Transmission::mutable_ranging_reply() {
  set_has_ranging_reply();
  if (ranging_reply_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::RangingReply>(GetArenaNoVirtual());
    ranging_reply_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.ranging_reply)
  return ranging_reply_;
}
inline void Transmission::set_allocated_ranging_reply(::goby::acomms::micromodem::protobuf::RangingReply* ranging_reply) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete ranging_reply_;
  }
  if (ranging_reply) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      ranging_reply = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, ranging_reply, submessage_arena);
    }
    set_has_ranging_reply();
  } else {
    clear_has_ranging_reply();
  }
  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::receive_stat_size() const {
  return receive_stat_.size();
}
inline void Transmission::clear_receive_stat() {
  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 receive_stat_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::ReceiveStatistics >*
Transmission::mutable_receive_stat() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.Transmission.receive_stat)
  return &receive_stat_;
}
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 receive_stat_.Get(index);
}
inline ::goby::acomms::micromodem::protobuf::ReceiveStatistics* Transmission::add_receive_stat() {
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Transmission.receive_stat)
  return receive_stat_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::ReceiveStatistics >&
Transmission::receive_stat() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.Transmission.receive_stat)
  return receive_stat_;
}
 
// repeated .goby.acomms.micromodem.protobuf.TransmitStatistics transmit_stat = 6 [(.goby.field) = {
inline int Transmission::transmit_stat_size() const {
  return transmit_stat_.size();
}
inline void Transmission::clear_transmit_stat() {
  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 transmit_stat_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::TransmitStatistics >*
Transmission::mutable_transmit_stat() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.Transmission.transmit_stat)
  return &transmit_stat_;
}
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 transmit_stat_.Get(index);
}
inline ::goby::acomms::micromodem::protobuf::TransmitStatistics* Transmission::add_transmit_stat() {
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Transmission.transmit_stat)
  return transmit_stat_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::TransmitStatistics >&
Transmission::transmit_stat() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.Transmission.transmit_stat)
  return transmit_stat_;
}
 
// repeated int32 frame_with_bad_crc = 7 [(.goby.field) = {
inline int Transmission::frame_with_bad_crc_size() const {
  return frame_with_bad_crc_.size();
}
inline void Transmission::clear_frame_with_bad_crc() {
  frame_with_bad_crc_.Clear();
}
inline ::google::protobuf::int32 Transmission::frame_with_bad_crc(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.frame_with_bad_crc)
  return frame_with_bad_crc_.Get(index);
}
inline void Transmission::set_frame_with_bad_crc(int index, ::google::protobuf::int32 value) {
  frame_with_bad_crc_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.acomms.micromodem.protobuf.Transmission.frame_with_bad_crc)
}
inline void Transmission::add_frame_with_bad_crc(::google::protobuf::int32 value) {
  frame_with_bad_crc_.Add(value);
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.Transmission.frame_with_bad_crc)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
Transmission::frame_with_bad_crc() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.Transmission.frame_with_bad_crc)
  return frame_with_bad_crc_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
Transmission::mutable_frame_with_bad_crc() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.Transmission.frame_with_bad_crc)
  return &frame_with_bad_crc_;
}
 
// optional .goby.acomms.micromodem.protobuf.HardwareControl hw_ctl = 8 [(.dccl.field) = {
inline bool Transmission::has_hw_ctl() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Transmission::set_has_hw_ctl() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Transmission::clear_has_hw_ctl() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Transmission::clear_hw_ctl() {
  if (hw_ctl_ != NULL) hw_ctl_->Clear();
  clear_has_hw_ctl();
}
inline const ::goby::acomms::micromodem::protobuf::HardwareControl& Transmission::_internal_hw_ctl() const {
  return *hw_ctl_;
}
inline const ::goby::acomms::micromodem::protobuf::HardwareControl& Transmission::hw_ctl() const {
  const ::goby::acomms::micromodem::protobuf::HardwareControl* p = hw_ctl_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.hw_ctl)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::HardwareControl*>(
      &::goby::acomms::micromodem::protobuf::_HardwareControl_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* Transmission::release_hw_ctl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.hw_ctl)
  clear_has_hw_ctl();
  ::goby::acomms::micromodem::protobuf::HardwareControl* temp = hw_ctl_;
  hw_ctl_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::HardwareControl* Transmission::mutable_hw_ctl() {
  set_has_hw_ctl();
  if (hw_ctl_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::HardwareControl>(GetArenaNoVirtual());
    hw_ctl_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.hw_ctl)
  return hw_ctl_;
}
inline void Transmission::set_allocated_hw_ctl(::goby::acomms::micromodem::protobuf::HardwareControl* hw_ctl) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete hw_ctl_;
  }
  if (hw_ctl) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      hw_ctl = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, hw_ctl, submessage_arena);
    }
    set_has_hw_ctl();
  } else {
    clear_has_hw_ctl();
  }
  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::has_generic_lbl() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Transmission::set_has_generic_lbl() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Transmission::clear_has_generic_lbl() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Transmission::clear_generic_lbl() {
  if (generic_lbl_ != NULL) generic_lbl_->Clear();
  clear_has_generic_lbl();
}
inline const ::goby::acomms::micromodem::protobuf::GenericLBLParams& Transmission::_internal_generic_lbl() const {
  return *generic_lbl_;
}
inline const ::goby::acomms::micromodem::protobuf::GenericLBLParams& Transmission::generic_lbl() const {
  const ::goby::acomms::micromodem::protobuf::GenericLBLParams* p = generic_lbl_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.generic_lbl)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::GenericLBLParams*>(
      &::goby::acomms::micromodem::protobuf::_GenericLBLParams_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Transmission::release_generic_lbl() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.generic_lbl)
  clear_has_generic_lbl();
  ::goby::acomms::micromodem::protobuf::GenericLBLParams* temp = generic_lbl_;
  generic_lbl_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::GenericLBLParams* Transmission::mutable_generic_lbl() {
  set_has_generic_lbl();
  if (generic_lbl_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::GenericLBLParams>(GetArenaNoVirtual());
    generic_lbl_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.generic_lbl)
  return generic_lbl_;
}
inline void Transmission::set_allocated_generic_lbl(::goby::acomms::micromodem::protobuf::GenericLBLParams* generic_lbl) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete generic_lbl_;
  }
  if (generic_lbl) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      generic_lbl = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, generic_lbl, submessage_arena);
    }
    set_has_generic_lbl();
  } else {
    clear_has_generic_lbl();
  }
  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::has_fm_sweep() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Transmission::set_has_fm_sweep() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Transmission::clear_has_fm_sweep() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Transmission::clear_fm_sweep() {
  if (fm_sweep_ != NULL) fm_sweep_->Clear();
  clear_has_fm_sweep();
}
inline const ::goby::acomms::micromodem::protobuf::FMSweepParams& Transmission::_internal_fm_sweep() const {
  return *fm_sweep_;
}
inline const ::goby::acomms::micromodem::protobuf::FMSweepParams& Transmission::fm_sweep() const {
  const ::goby::acomms::micromodem::protobuf::FMSweepParams* p = fm_sweep_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.fm_sweep)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::FMSweepParams*>(
      &::goby::acomms::micromodem::protobuf::_FMSweepParams_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Transmission::release_fm_sweep() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.fm_sweep)
  clear_has_fm_sweep();
  ::goby::acomms::micromodem::protobuf::FMSweepParams* temp = fm_sweep_;
  fm_sweep_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::FMSweepParams* Transmission::mutable_fm_sweep() {
  set_has_fm_sweep();
  if (fm_sweep_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::FMSweepParams>(GetArenaNoVirtual());
    fm_sweep_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.fm_sweep)
  return fm_sweep_;
}
inline void Transmission::set_allocated_fm_sweep(::goby::acomms::micromodem::protobuf::FMSweepParams* fm_sweep) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete fm_sweep_;
  }
  if (fm_sweep) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      fm_sweep = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, fm_sweep, submessage_arena);
    }
    set_has_fm_sweep();
  } else {
    clear_has_fm_sweep();
  }
  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::has_m_sequence() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Transmission::set_has_m_sequence() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Transmission::clear_has_m_sequence() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Transmission::clear_m_sequence() {
  if (m_sequence_ != NULL) m_sequence_->Clear();
  clear_has_m_sequence();
}
inline const ::goby::acomms::micromodem::protobuf::MSequenceParams& Transmission::_internal_m_sequence() const {
  return *m_sequence_;
}
inline const ::goby::acomms::micromodem::protobuf::MSequenceParams& Transmission::m_sequence() const {
  const ::goby::acomms::micromodem::protobuf::MSequenceParams* p = m_sequence_;
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.Transmission.m_sequence)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::acomms::micromodem::protobuf::MSequenceParams*>(
      &::goby::acomms::micromodem::protobuf::_MSequenceParams_default_instance_);
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Transmission::release_m_sequence() {
  // @@protoc_insertion_point(field_release:goby.acomms.micromodem.protobuf.Transmission.m_sequence)
  clear_has_m_sequence();
  ::goby::acomms::micromodem::protobuf::MSequenceParams* temp = m_sequence_;
  m_sequence_ = NULL;
  return temp;
}
inline ::goby::acomms::micromodem::protobuf::MSequenceParams* Transmission::mutable_m_sequence() {
  set_has_m_sequence();
  if (m_sequence_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::acomms::micromodem::protobuf::MSequenceParams>(GetArenaNoVirtual());
    m_sequence_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.acomms.micromodem.protobuf.Transmission.m_sequence)
  return m_sequence_;
}
inline void Transmission::set_allocated_m_sequence(::goby::acomms::micromodem::protobuf::MSequenceParams* m_sequence) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete m_sequence_;
  }
  if (m_sequence) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      m_sequence = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, m_sequence, submessage_arena);
    }
    set_has_m_sequence();
  } else {
    clear_has_m_sequence();
  }
  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::has_ack_dest() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MMApplicationAck_AckPart::set_has_ack_dest() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MMApplicationAck_AckPart::clear_has_ack_dest() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MMApplicationAck_AckPart::clear_ack_dest() {
  ack_dest_ = 0;
  clear_has_ack_dest();
}
inline ::google::protobuf::int32 MMApplicationAck_AckPart::ack_dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart.ack_dest)
  return ack_dest_;
}
inline void MMApplicationAck_AckPart::set_ack_dest(::google::protobuf::int32 value) {
  set_has_ack_dest();
  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::has_acked_frames() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MMApplicationAck_AckPart::set_has_acked_frames() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MMApplicationAck_AckPart::clear_has_acked_frames() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MMApplicationAck_AckPart::clear_acked_frames() {
  acked_frames_ = 0u;
  clear_has_acked_frames();
}
inline ::google::protobuf::uint32 MMApplicationAck_AckPart::acked_frames() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MMApplicationAck.AckPart.acked_frames)
  return acked_frames_;
}
inline void MMApplicationAck_AckPart::set_acked_frames(::google::protobuf::uint32 value) {
  set_has_acked_frames();
  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::part_size() const {
  return part_.size();
}
inline void MMApplicationAck::clear_part() {
  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 part_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart >*
MMApplicationAck::mutable_part() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.micromodem.protobuf.MMApplicationAck.part)
  return &part_;
}
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 part_.Get(index);
}
inline ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart* MMApplicationAck::add_part() {
  // @@protoc_insertion_point(field_add:goby.acomms.micromodem.protobuf.MMApplicationAck.part)
  return part_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::acomms::micromodem::protobuf::MMApplicationAck_AckPart >&
MMApplicationAck::part() const {
  // @@protoc_insertion_point(field_list:goby.acomms.micromodem.protobuf.MMApplicationAck.part)
  return part_;
}
 
// required bool ack_requested = 3;
inline bool MMApplicationAck::has_ack_requested() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MMApplicationAck::set_has_ack_requested() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MMApplicationAck::clear_has_ack_requested() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MMApplicationAck::clear_ack_requested() {
  ack_requested_ = false;
  clear_has_ack_requested();
}
inline bool MMApplicationAck::ack_requested() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MMApplicationAck.ack_requested)
  return ack_requested_;
}
inline void MMApplicationAck::set_ack_requested(bool value) {
  set_has_ack_requested();
  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::has_frame_start() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MMApplicationAck::set_has_frame_start() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MMApplicationAck::clear_has_frame_start() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MMApplicationAck::clear_frame_start() {
  frame_start_ = 0u;
  clear_has_frame_start();
}
inline ::google::protobuf::uint32 MMApplicationAck::frame_start() const {
  // @@protoc_insertion_point(field_get:goby.acomms.micromodem.protobuf.MMApplicationAck.frame_start)
  return frame_start_;
}
inline void MMApplicationAck::set_frame_start(::google::protobuf::uint32 value) {
  set_has_frame_start();
  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
 
namespace google {
namespace protobuf {
 
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();
}
 
}  // namespace protobuf
}  // namespace google
 
// @@protoc_insertion_point(global_scope)
 
#endif  // PROTOBUF_INCLUDED_goby_2facomms_2fprotobuf_2fmm_5fdriver_2eproto