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

#include "config.pb.h"

#include <algorithm>
#include <type_traits>
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/generated_message_tctable_impl.h"
#include "google/protobuf/internal_visibility.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/wire_format_lite.h"
#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::google::protobuf;
namespace _pbi = ::google::protobuf::internal;
namespace _fl = ::google::protobuf::internal::field_layout;
namespace webrtc {
namespace audio_network_adaptor {
namespace config {
class FrameLengthControllerV2::_Internal {
 public:
  using HasBits = decltype(::std::declval<FrameLengthControllerV2>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(FrameLengthControllerV2, _impl_._has_bits_);
};

constexpr FrameLengthControllerV2::ParseTableT_ FrameLengthControllerV2::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(FrameLengthControllerV2, _impl_._has_bits_),
      0, // no _extensions_
      2, 8,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FrameLengthControllerV2>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional bool use_slow_adaptation = 2;
      {::_pbi::TcParser::FastV8S1,
       {16, 1, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthControllerV2, _impl_.use_slow_adaptation_)}},
      // optional int32 min_payload_bitrate_bps = 1;
      {::_pbi::TcParser::FastV32S1,
       {8, 0, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthControllerV2, _impl_.min_payload_bitrate_bps_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional int32 min_payload_bitrate_bps = 1;
      {PROTOBUF_FIELD_OFFSET(FrameLengthControllerV2, _impl_.min_payload_bitrate_bps_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional bool use_slow_adaptation = 2;
      {PROTOBUF_FIELD_OFFSET(FrameLengthControllerV2, _impl_.use_slow_adaptation_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr FrameLengthControllerV2::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        min_payload_bitrate_bps_{0},
        use_slow_adaptation_{false} {}

template <typename>
constexpr FrameLengthControllerV2::FrameLengthControllerV2(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL FrameLengthControllerV2::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) FrameLengthControllerV2(arena);
}
constexpr auto FrameLengthControllerV2::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(FrameLengthControllerV2), alignof(FrameLengthControllerV2));
}
constexpr auto FrameLengthControllerV2::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &FrameLengthControllerV2::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<FrameLengthControllerV2>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &FrameLengthControllerV2::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<FrameLengthControllerV2>(), &FrameLengthControllerV2::ByteSizeLong,
              &FrameLengthControllerV2::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(FrameLengthControllerV2, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.FrameLengthControllerV2",
  };
}
struct FrameLengthControllerV2GlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr FrameLengthControllerV2GlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 FrameLengthControllerV2_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(FrameLengthControllerV2::InternalGenerateClassData_(
            _default, &FrameLengthControllerV2_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<FrameLengthControllerV2>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~FrameLengthControllerV2GlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) FrameLengthControllerV2 _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<FrameLengthControllerV2>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(FrameLengthControllerV2GlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST FrameLengthControllerV2GlobalsTypeInternal FrameLengthControllerV2_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* FrameLengthControllerV2_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return FrameLengthControllerV2_globals_.GetClassData();
#else
  return FrameLengthControllerV2_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class FrameLengthController::_Internal {
 public:
  using HasBits = decltype(::std::declval<FrameLengthController>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_._has_bits_);
};

constexpr FrameLengthController::ParseTableT_ FrameLengthController::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_._has_bits_),
      0, // no _extensions_
      12, 120,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294963200,  // skipmap
      offsetof(ParseTableT_, field_entries),
      12,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FrameLengthController>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // optional float fl_increasing_packet_loss_fraction = 1;
      {::_pbi::TcParser::FastF32S1,
       {13, 0, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_increasing_packet_loss_fraction_)}},
      // optional float fl_decreasing_packet_loss_fraction = 2;
      {::_pbi::TcParser::FastF32S1,
       {21, 1, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_decreasing_packet_loss_fraction_)}},
      // optional int32 fl_20ms_to_60ms_bandwidth_bps = 3;
      {::_pbi::TcParser::FastV32S1,
       {24, 2, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_20ms_to_60ms_bandwidth_bps_)}},
      // optional int32 fl_60ms_to_20ms_bandwidth_bps = 4;
      {::_pbi::TcParser::FastV32S1,
       {32, 3, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_60ms_to_20ms_bandwidth_bps_)}},
      // optional int32 fl_60ms_to_120ms_bandwidth_bps = 5;
      {::_pbi::TcParser::FastV32S1,
       {40, 4, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_60ms_to_120ms_bandwidth_bps_)}},
      // optional int32 fl_120ms_to_60ms_bandwidth_bps = 6;
      {::_pbi::TcParser::FastV32S1,
       {48, 5, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_120ms_to_60ms_bandwidth_bps_)}},
      // optional int32 fl_increase_overhead_offset = 7;
      {::_pbi::TcParser::FastV32S1,
       {56, 6, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_increase_overhead_offset_)}},
      // optional int32 fl_decrease_overhead_offset = 8;
      {::_pbi::TcParser::FastV32S1,
       {64, 7, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_decrease_overhead_offset_)}},
      // optional int32 fl_20ms_to_40ms_bandwidth_bps = 9;
      {::_pbi::TcParser::FastV32S1,
       {72, 8, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_20ms_to_40ms_bandwidth_bps_)}},
      // optional int32 fl_40ms_to_20ms_bandwidth_bps = 10;
      {::_pbi::TcParser::FastV32S1,
       {80, 9, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_40ms_to_20ms_bandwidth_bps_)}},
      // optional int32 fl_40ms_to_60ms_bandwidth_bps = 11;
      {::_pbi::TcParser::FastV32S1,
       {88, 10, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_40ms_to_60ms_bandwidth_bps_)}},
      // optional int32 fl_60ms_to_40ms_bandwidth_bps = 12;
      {::_pbi::TcParser::FastV32S1,
       {96, 11, 0,
        PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_60ms_to_40ms_bandwidth_bps_)}},
      {::_pbi::TcParser::MiniParse, {}},
      {::_pbi::TcParser::MiniParse, {}},
      {::_pbi::TcParser::MiniParse, {}},
    }}, {{
      65535, 65535
    }}, {{
      // optional float fl_increasing_packet_loss_fraction = 1;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_increasing_packet_loss_fraction_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)},
      // optional float fl_decreasing_packet_loss_fraction = 2;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_decreasing_packet_loss_fraction_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)},
      // optional int32 fl_20ms_to_60ms_bandwidth_bps = 3;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_20ms_to_60ms_bandwidth_bps_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 fl_60ms_to_20ms_bandwidth_bps = 4;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_60ms_to_20ms_bandwidth_bps_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 fl_60ms_to_120ms_bandwidth_bps = 5;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_60ms_to_120ms_bandwidth_bps_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 fl_120ms_to_60ms_bandwidth_bps = 6;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_120ms_to_60ms_bandwidth_bps_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 fl_increase_overhead_offset = 7;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_increase_overhead_offset_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 fl_decrease_overhead_offset = 8;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_decrease_overhead_offset_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 fl_20ms_to_40ms_bandwidth_bps = 9;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_20ms_to_40ms_bandwidth_bps_), _Internal::kHasBitsOffset + 8, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 fl_40ms_to_20ms_bandwidth_bps = 10;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_40ms_to_20ms_bandwidth_bps_), _Internal::kHasBitsOffset + 9, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 fl_40ms_to_60ms_bandwidth_bps = 11;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_40ms_to_60ms_bandwidth_bps_), _Internal::kHasBitsOffset + 10, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 fl_60ms_to_40ms_bandwidth_bps = 12;
      {PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_60ms_to_40ms_bandwidth_bps_), _Internal::kHasBitsOffset + 11, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr FrameLengthController::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        fl_increasing_packet_loss_fraction_{0},
        fl_decreasing_packet_loss_fraction_{0},
        fl_20ms_to_60ms_bandwidth_bps_{0},
        fl_60ms_to_20ms_bandwidth_bps_{0},
        fl_60ms_to_120ms_bandwidth_bps_{0},
        fl_120ms_to_60ms_bandwidth_bps_{0},
        fl_increase_overhead_offset_{0},
        fl_decrease_overhead_offset_{0},
        fl_20ms_to_40ms_bandwidth_bps_{0},
        fl_40ms_to_20ms_bandwidth_bps_{0},
        fl_40ms_to_60ms_bandwidth_bps_{0},
        fl_60ms_to_40ms_bandwidth_bps_{0} {}

template <typename>
constexpr FrameLengthController::FrameLengthController(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL FrameLengthController::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) FrameLengthController(arena);
}
constexpr auto FrameLengthController::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(FrameLengthController), alignof(FrameLengthController));
}
constexpr auto FrameLengthController::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &FrameLengthController::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<FrameLengthController>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &FrameLengthController::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<FrameLengthController>(), &FrameLengthController::ByteSizeLong,
              &FrameLengthController::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.FrameLengthController",
  };
}
struct FrameLengthControllerGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr FrameLengthControllerGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 FrameLengthController_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(FrameLengthController::InternalGenerateClassData_(
            _default, &FrameLengthController_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<FrameLengthController>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~FrameLengthControllerGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) FrameLengthController _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<FrameLengthController>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(FrameLengthControllerGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST FrameLengthControllerGlobalsTypeInternal FrameLengthController_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* FrameLengthController_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return FrameLengthController_globals_.GetClassData();
#else
  return FrameLengthController_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class FecControllerRplrBased_Threshold::_Internal {
 public:
  using HasBits = decltype(::std::declval<FecControllerRplrBased_Threshold>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_._has_bits_);
};

constexpr FecControllerRplrBased_Threshold::ParseTableT_ FecControllerRplrBased_Threshold::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_._has_bits_),
      0, // no _extensions_
      4, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967280,  // skipmap
      offsetof(ParseTableT_, field_entries),
      4,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional float high_bandwidth_recoverable_packet_loss = 4;
      {::_pbi::TcParser::FastF32S1,
       {37, 3, 0,
        PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_.high_bandwidth_recoverable_packet_loss_)}},
      // optional int32 low_bandwidth_bps = 1;
      {::_pbi::TcParser::FastV32S1,
       {8, 0, 0,
        PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_.low_bandwidth_bps_)}},
      // optional float low_bandwidth_recoverable_packet_loss = 2;
      {::_pbi::TcParser::FastF32S1,
       {21, 1, 0,
        PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_.low_bandwidth_recoverable_packet_loss_)}},
      // optional int32 high_bandwidth_bps = 3;
      {::_pbi::TcParser::FastV32S1,
       {24, 2, 0,
        PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_.high_bandwidth_bps_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional int32 low_bandwidth_bps = 1;
      {PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_.low_bandwidth_bps_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional float low_bandwidth_recoverable_packet_loss = 2;
      {PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_.low_bandwidth_recoverable_packet_loss_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)},
      // optional int32 high_bandwidth_bps = 3;
      {PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_.high_bandwidth_bps_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional float high_bandwidth_recoverable_packet_loss = 4;
      {PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_.high_bandwidth_recoverable_packet_loss_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr FecControllerRplrBased_Threshold::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        low_bandwidth_bps_{0},
        low_bandwidth_recoverable_packet_loss_{0},
        high_bandwidth_bps_{0},
        high_bandwidth_recoverable_packet_loss_{0} {}

template <typename>
constexpr FecControllerRplrBased_Threshold::FecControllerRplrBased_Threshold(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL FecControllerRplrBased_Threshold::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) FecControllerRplrBased_Threshold(arena);
}
constexpr auto FecControllerRplrBased_Threshold::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(FecControllerRplrBased_Threshold), alignof(FecControllerRplrBased_Threshold));
}
constexpr auto FecControllerRplrBased_Threshold::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &FecControllerRplrBased_Threshold::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<FecControllerRplrBased_Threshold>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &FecControllerRplrBased_Threshold::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<FecControllerRplrBased_Threshold>(), &FecControllerRplrBased_Threshold::ByteSizeLong,
              &FecControllerRplrBased_Threshold::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold",
  };
}
struct FecControllerRplrBased_ThresholdGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr FecControllerRplrBased_ThresholdGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 FecControllerRplrBased_Threshold_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(FecControllerRplrBased_Threshold::InternalGenerateClassData_(
            _default, &FecControllerRplrBased_Threshold_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<FecControllerRplrBased_Threshold>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~FecControllerRplrBased_ThresholdGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) FecControllerRplrBased_Threshold _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<FecControllerRplrBased_Threshold>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_ThresholdGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST FecControllerRplrBased_ThresholdGlobalsTypeInternal FecControllerRplrBased_Threshold_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* FecControllerRplrBased_Threshold_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return FecControllerRplrBased_Threshold_globals_.GetClassData();
#else
  return FecControllerRplrBased_Threshold_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class FecController_Threshold::_Internal {
 public:
  using HasBits = decltype(::std::declval<FecController_Threshold>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_._has_bits_);
};

constexpr FecController_Threshold::ParseTableT_ FecController_Threshold::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_._has_bits_),
      0, // no _extensions_
      4, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967280,  // skipmap
      offsetof(ParseTableT_, field_entries),
      4,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FecController_Threshold>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional float high_bandwidth_packet_loss = 4;
      {::_pbi::TcParser::FastF32S1,
       {37, 3, 0,
        PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_.high_bandwidth_packet_loss_)}},
      // optional int32 low_bandwidth_bps = 1;
      {::_pbi::TcParser::FastV32S1,
       {8, 0, 0,
        PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_.low_bandwidth_bps_)}},
      // optional float low_bandwidth_packet_loss = 2;
      {::_pbi::TcParser::FastF32S1,
       {21, 1, 0,
        PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_.low_bandwidth_packet_loss_)}},
      // optional int32 high_bandwidth_bps = 3;
      {::_pbi::TcParser::FastV32S1,
       {24, 2, 0,
        PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_.high_bandwidth_bps_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional int32 low_bandwidth_bps = 1;
      {PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_.low_bandwidth_bps_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional float low_bandwidth_packet_loss = 2;
      {PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_.low_bandwidth_packet_loss_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)},
      // optional int32 high_bandwidth_bps = 3;
      {PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_.high_bandwidth_bps_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional float high_bandwidth_packet_loss = 4;
      {PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_.high_bandwidth_packet_loss_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr FecController_Threshold::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        low_bandwidth_bps_{0},
        low_bandwidth_packet_loss_{0},
        high_bandwidth_bps_{0},
        high_bandwidth_packet_loss_{0} {}

template <typename>
constexpr FecController_Threshold::FecController_Threshold(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL FecController_Threshold::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) FecController_Threshold(arena);
}
constexpr auto FecController_Threshold::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(FecController_Threshold), alignof(FecController_Threshold));
}
constexpr auto FecController_Threshold::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &FecController_Threshold::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<FecController_Threshold>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &FecController_Threshold::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<FecController_Threshold>(), &FecController_Threshold::ByteSizeLong,
              &FecController_Threshold::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.FecController.Threshold",
  };
}
struct FecController_ThresholdGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr FecController_ThresholdGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 FecController_Threshold_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(FecController_Threshold::InternalGenerateClassData_(
            _default, &FecController_Threshold_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<FecController_Threshold>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~FecController_ThresholdGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) FecController_Threshold _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<FecController_Threshold>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(FecController_ThresholdGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST FecController_ThresholdGlobalsTypeInternal FecController_Threshold_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* FecController_Threshold_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return FecController_Threshold_globals_.GetClassData();
#else
  return FecController_Threshold_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class DtxController::_Internal {
 public:
  using HasBits = decltype(::std::declval<DtxController>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(DtxController, _impl_._has_bits_);
};

constexpr DtxController::ParseTableT_ DtxController::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(DtxController, _impl_._has_bits_),
      0, // no _extensions_
      2, 8,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::DtxController>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional int32 dtx_disabling_bandwidth_bps = 2;
      {::_pbi::TcParser::FastV32S1,
       {16, 1, 0,
        PROTOBUF_FIELD_OFFSET(DtxController, _impl_.dtx_disabling_bandwidth_bps_)}},
      // optional int32 dtx_enabling_bandwidth_bps = 1;
      {::_pbi::TcParser::FastV32S1,
       {8, 0, 0,
        PROTOBUF_FIELD_OFFSET(DtxController, _impl_.dtx_enabling_bandwidth_bps_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional int32 dtx_enabling_bandwidth_bps = 1;
      {PROTOBUF_FIELD_OFFSET(DtxController, _impl_.dtx_enabling_bandwidth_bps_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 dtx_disabling_bandwidth_bps = 2;
      {PROTOBUF_FIELD_OFFSET(DtxController, _impl_.dtx_disabling_bandwidth_bps_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr DtxController::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        dtx_enabling_bandwidth_bps_{0},
        dtx_disabling_bandwidth_bps_{0} {}

template <typename>
constexpr DtxController::DtxController(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL DtxController::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) DtxController(arena);
}
constexpr auto DtxController::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(DtxController), alignof(DtxController));
}
constexpr auto DtxController::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &DtxController::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<DtxController>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &DtxController::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<DtxController>(), &DtxController::ByteSizeLong,
              &DtxController::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(DtxController, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.DtxController",
  };
}
struct DtxControllerGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr DtxControllerGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 DtxController_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(DtxController::InternalGenerateClassData_(
            _default, &DtxController_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<DtxController>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~DtxControllerGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) DtxController _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<DtxController>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(DtxControllerGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST DtxControllerGlobalsTypeInternal DtxController_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* DtxController_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return DtxController_globals_.GetClassData();
#else
  return DtxController_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class Controller_ScoringPoint::_Internal {
 public:
  using HasBits = decltype(::std::declval<Controller_ScoringPoint>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(Controller_ScoringPoint, _impl_._has_bits_);
};

constexpr Controller_ScoringPoint::ParseTableT_ Controller_ScoringPoint::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(Controller_ScoringPoint, _impl_._has_bits_),
      0, // no _extensions_
      2, 8,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::Controller_ScoringPoint>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional float uplink_packet_loss_fraction = 2;
      {::_pbi::TcParser::FastF32S1,
       {21, 1, 0,
        PROTOBUF_FIELD_OFFSET(Controller_ScoringPoint, _impl_.uplink_packet_loss_fraction_)}},
      // optional int32 uplink_bandwidth_bps = 1;
      {::_pbi::TcParser::FastV32S1,
       {8, 0, 0,
        PROTOBUF_FIELD_OFFSET(Controller_ScoringPoint, _impl_.uplink_bandwidth_bps_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional int32 uplink_bandwidth_bps = 1;
      {PROTOBUF_FIELD_OFFSET(Controller_ScoringPoint, _impl_.uplink_bandwidth_bps_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional float uplink_packet_loss_fraction = 2;
      {PROTOBUF_FIELD_OFFSET(Controller_ScoringPoint, _impl_.uplink_packet_loss_fraction_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr Controller_ScoringPoint::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        uplink_bandwidth_bps_{0},
        uplink_packet_loss_fraction_{0} {}

template <typename>
constexpr Controller_ScoringPoint::Controller_ScoringPoint(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL Controller_ScoringPoint::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) Controller_ScoringPoint(arena);
}
constexpr auto Controller_ScoringPoint::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Controller_ScoringPoint), alignof(Controller_ScoringPoint));
}
constexpr auto Controller_ScoringPoint::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &Controller_ScoringPoint::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<Controller_ScoringPoint>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &Controller_ScoringPoint::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<Controller_ScoringPoint>(), &Controller_ScoringPoint::ByteSizeLong,
              &Controller_ScoringPoint::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(Controller_ScoringPoint, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.Controller.ScoringPoint",
  };
}
struct Controller_ScoringPointGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr Controller_ScoringPointGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 Controller_ScoringPoint_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(Controller_ScoringPoint::InternalGenerateClassData_(
            _default, &Controller_ScoringPoint_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<Controller_ScoringPoint>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~Controller_ScoringPointGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) Controller_ScoringPoint _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<Controller_ScoringPoint>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(Controller_ScoringPointGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST Controller_ScoringPointGlobalsTypeInternal Controller_ScoringPoint_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* Controller_ScoringPoint_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return Controller_ScoringPoint_globals_.GetClassData();
#else
  return Controller_ScoringPoint_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class ChannelController::_Internal {
 public:
  using HasBits = decltype(::std::declval<ChannelController>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(ChannelController, _impl_._has_bits_);
};

constexpr ChannelController::ParseTableT_ ChannelController::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(ChannelController, _impl_._has_bits_),
      0, // no _extensions_
      2, 8,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::ChannelController>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional int32 channel_2_to_1_bandwidth_bps = 2;
      {::_pbi::TcParser::FastV32S1,
       {16, 1, 0,
        PROTOBUF_FIELD_OFFSET(ChannelController, _impl_.channel_2_to_1_bandwidth_bps_)}},
      // optional int32 channel_1_to_2_bandwidth_bps = 1;
      {::_pbi::TcParser::FastV32S1,
       {8, 0, 0,
        PROTOBUF_FIELD_OFFSET(ChannelController, _impl_.channel_1_to_2_bandwidth_bps_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional int32 channel_1_to_2_bandwidth_bps = 1;
      {PROTOBUF_FIELD_OFFSET(ChannelController, _impl_.channel_1_to_2_bandwidth_bps_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 channel_2_to_1_bandwidth_bps = 2;
      {PROTOBUF_FIELD_OFFSET(ChannelController, _impl_.channel_2_to_1_bandwidth_bps_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr ChannelController::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        channel_1_to_2_bandwidth_bps_{0},
        channel_2_to_1_bandwidth_bps_{0} {}

template <typename>
constexpr ChannelController::ChannelController(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL ChannelController::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) ChannelController(arena);
}
constexpr auto ChannelController::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ChannelController), alignof(ChannelController));
}
constexpr auto ChannelController::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &ChannelController::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<ChannelController>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &ChannelController::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<ChannelController>(), &ChannelController::ByteSizeLong,
              &ChannelController::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(ChannelController, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.ChannelController",
  };
}
struct ChannelControllerGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr ChannelControllerGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 ChannelController_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(ChannelController::InternalGenerateClassData_(
            _default, &ChannelController_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<ChannelController>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~ChannelControllerGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) ChannelController _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<ChannelController>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(ChannelControllerGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST ChannelControllerGlobalsTypeInternal ChannelController_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* ChannelController_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return ChannelController_globals_.GetClassData();
#else
  return ChannelController_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class BitrateController::_Internal {
 public:
  using HasBits = decltype(::std::declval<BitrateController>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(BitrateController, _impl_._has_bits_);
};

constexpr BitrateController::ParseTableT_ BitrateController::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(BitrateController, _impl_._has_bits_),
      0, // no _extensions_
      2, 8,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::BitrateController>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional int32 fl_decrease_overhead_offset = 2;
      {::_pbi::TcParser::FastV32S1,
       {16, 1, 0,
        PROTOBUF_FIELD_OFFSET(BitrateController, _impl_.fl_decrease_overhead_offset_)}},
      // optional int32 fl_increase_overhead_offset = 1;
      {::_pbi::TcParser::FastV32S1,
       {8, 0, 0,
        PROTOBUF_FIELD_OFFSET(BitrateController, _impl_.fl_increase_overhead_offset_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional int32 fl_increase_overhead_offset = 1;
      {PROTOBUF_FIELD_OFFSET(BitrateController, _impl_.fl_increase_overhead_offset_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 fl_decrease_overhead_offset = 2;
      {PROTOBUF_FIELD_OFFSET(BitrateController, _impl_.fl_decrease_overhead_offset_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr BitrateController::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        fl_increase_overhead_offset_{0},
        fl_decrease_overhead_offset_{0} {}

template <typename>
constexpr BitrateController::BitrateController(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL BitrateController::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) BitrateController(arena);
}
constexpr auto BitrateController::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(BitrateController), alignof(BitrateController));
}
constexpr auto BitrateController::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &BitrateController::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<BitrateController>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &BitrateController::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<BitrateController>(), &BitrateController::ByteSizeLong,
              &BitrateController::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(BitrateController, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.BitrateController",
  };
}
struct BitrateControllerGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr BitrateControllerGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 BitrateController_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(BitrateController::InternalGenerateClassData_(
            _default, &BitrateController_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<BitrateController>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~BitrateControllerGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) BitrateController _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<BitrateController>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(BitrateControllerGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST BitrateControllerGlobalsTypeInternal BitrateController_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* BitrateController_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return BitrateController_globals_.GetClassData();
#else
  return BitrateController_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class FecControllerRplrBased::_Internal {
 public:
  using HasBits = decltype(::std::declval<FecControllerRplrBased>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(FecControllerRplrBased, _impl_._has_bits_);
};

constexpr FecControllerRplrBased::ParseTableT_ FecControllerRplrBased::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(FecControllerRplrBased, _impl_._has_bits_),
      0, // no _extensions_
      2, 8,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      2,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FecControllerRplrBased>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_disabling_threshold = 2;
      {::_pbi::TcParser::FastMtS1,
       {18, 1, 1,
        PROTOBUF_FIELD_OFFSET(FecControllerRplrBased, _impl_.fec_disabling_threshold_)}},
      // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_enabling_threshold = 1;
      {::_pbi::TcParser::FastMtS1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(FecControllerRplrBased, _impl_.fec_enabling_threshold_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_enabling_threshold = 1;
      {PROTOBUF_FIELD_OFFSET(FecControllerRplrBased, _impl_.fec_enabling_threshold_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_disabling_threshold = 2;
      {PROTOBUF_FIELD_OFFSET(FecControllerRplrBased, _impl_.fec_disabling_threshold_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr FecControllerRplrBased::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        fec_enabling_threshold_{nullptr},
        fec_disabling_threshold_{nullptr} {}

template <typename>
constexpr FecControllerRplrBased::FecControllerRplrBased(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL FecControllerRplrBased::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) FecControllerRplrBased(arena);
}
constexpr auto FecControllerRplrBased::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(FecControllerRplrBased), alignof(FecControllerRplrBased));
}
constexpr auto FecControllerRplrBased::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &FecControllerRplrBased::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<FecControllerRplrBased>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &FecControllerRplrBased::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<FecControllerRplrBased>(), &FecControllerRplrBased::ByteSizeLong,
              &FecControllerRplrBased::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(FecControllerRplrBased, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.FecControllerRplrBased",
  };
}
struct FecControllerRplrBasedGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr FecControllerRplrBasedGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 FecControllerRplrBased_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(FecControllerRplrBased::InternalGenerateClassData_(
            _default, &FecControllerRplrBased_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<FecControllerRplrBased>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~FecControllerRplrBasedGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) FecControllerRplrBased _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<FecControllerRplrBased>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(FecControllerRplrBasedGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST FecControllerRplrBasedGlobalsTypeInternal FecControllerRplrBased_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* FecControllerRplrBased_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return FecControllerRplrBased_globals_.GetClassData();
#else
  return FecControllerRplrBased_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class FecController::_Internal {
 public:
  using HasBits = decltype(::std::declval<FecController>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(FecController, _impl_._has_bits_);
};

constexpr FecController::ParseTableT_ FecController::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(FecController, _impl_._has_bits_),
      0, // no _extensions_
      3, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967288,  // skipmap
      offsetof(ParseTableT_, field_entries),
      3,  // num_field_entries
      2,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FecController>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_enabling_threshold = 1;
      {::_pbi::TcParser::FastMtS1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(FecController, _impl_.fec_enabling_threshold_)}},
      // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_disabling_threshold = 2;
      {::_pbi::TcParser::FastMtS1,
       {18, 1, 1,
        PROTOBUF_FIELD_OFFSET(FecController, _impl_.fec_disabling_threshold_)}},
      // optional int32 time_constant_ms = 3;
      {::_pbi::TcParser::FastV32S1,
       {24, 2, 0,
        PROTOBUF_FIELD_OFFSET(FecController, _impl_.time_constant_ms_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_enabling_threshold = 1;
      {PROTOBUF_FIELD_OFFSET(FecController, _impl_.fec_enabling_threshold_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_disabling_threshold = 2;
      {PROTOBUF_FIELD_OFFSET(FecController, _impl_.fec_disabling_threshold_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional int32 time_constant_ms = 3;
      {PROTOBUF_FIELD_OFFSET(FecController, _impl_.time_constant_ms_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FecController_Threshold>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::FecController_Threshold_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FecController_Threshold>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::FecController_Threshold_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr FecController::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        fec_enabling_threshold_{nullptr},
        fec_disabling_threshold_{nullptr},
        time_constant_ms_{0} {}

template <typename>
constexpr FecController::FecController(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL FecController::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) FecController(arena);
}
constexpr auto FecController::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(FecController), alignof(FecController));
}
constexpr auto FecController::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &FecController::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<FecController>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &FecController::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<FecController>(), &FecController::ByteSizeLong,
              &FecController::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(FecController, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.FecController",
  };
}
struct FecControllerGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr FecControllerGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 FecController_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(FecController::InternalGenerateClassData_(
            _default, &FecController_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<FecController>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~FecControllerGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) FecController _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<FecController>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(FecControllerGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST FecControllerGlobalsTypeInternal FecController_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* FecController_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return FecController_globals_.GetClassData();
#else
  return FecController_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class Controller::_Internal {
 public:
  using HasBits = decltype(::std::declval<Controller>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(Controller, _impl_._has_bits_);
  static constexpr ::int32_t kOneofCaseOffset =
      PROTOBUF_FIELD_OFFSET(::webrtc::audio_network_adaptor::config::Controller, _impl_._oneof_case_);
};

constexpr Controller::ParseTableT_ Controller::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(Controller, _impl_._has_bits_),
      0, // no _extensions_
      27, 0,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4161798142,  // skipmap
      offsetof(ParseTableT_, field_entries),
      8,  // num_field_entries
      8,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::Controller>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional .webrtc.audio_network_adaptor.config.Controller.ScoringPoint scoring_point = 1;
      {::_pbi::TcParser::FastMtS1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(Controller, _impl_.scoring_point_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional .webrtc.audio_network_adaptor.config.Controller.ScoringPoint scoring_point = 1;
      {PROTOBUF_FIELD_OFFSET(Controller, _impl_.scoring_point_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // .webrtc.audio_network_adaptor.config.FecController fec_controller = 21;
      {PROTOBUF_FIELD_OFFSET(Controller, _impl_.controller_.fec_controller_), _Internal::kOneofCaseOffset + 0, 1, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
      // .webrtc.audio_network_adaptor.config.FrameLengthController frame_length_controller = 22;
      {PROTOBUF_FIELD_OFFSET(Controller, _impl_.controller_.frame_length_controller_), _Internal::kOneofCaseOffset + 0, 2, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
      // .webrtc.audio_network_adaptor.config.ChannelController channel_controller = 23;
      {PROTOBUF_FIELD_OFFSET(Controller, _impl_.controller_.channel_controller_), _Internal::kOneofCaseOffset + 0, 3, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
      // .webrtc.audio_network_adaptor.config.DtxController dtx_controller = 24;
      {PROTOBUF_FIELD_OFFSET(Controller, _impl_.controller_.dtx_controller_), _Internal::kOneofCaseOffset + 0, 4, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
      // .webrtc.audio_network_adaptor.config.BitrateController bitrate_controller = 25;
      {PROTOBUF_FIELD_OFFSET(Controller, _impl_.controller_.bitrate_controller_), _Internal::kOneofCaseOffset + 0, 5, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
      // .webrtc.audio_network_adaptor.config.FecControllerRplrBased fec_controller_rplr_based = 26;
      {PROTOBUF_FIELD_OFFSET(Controller, _impl_.controller_.fec_controller_rplr_based_), _Internal::kOneofCaseOffset + 0, 6, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
      // .webrtc.audio_network_adaptor.config.FrameLengthControllerV2 frame_length_controller_v2 = 27;
      {PROTOBUF_FIELD_OFFSET(Controller, _impl_.controller_.frame_length_controller_v2_), _Internal::kOneofCaseOffset + 0, 7, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::Controller_ScoringPoint>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::Controller_ScoringPoint_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FecController>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::FecController_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FrameLengthController>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::FrameLengthController_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::ChannelController>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::ChannelController_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::DtxController>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::DtxController_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::BitrateController>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::BitrateController_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FecControllerRplrBased>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::FecControllerRplrBased_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::FrameLengthControllerV2>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::FrameLengthControllerV2_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr Controller::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        scoring_point_{nullptr},
        controller_{},
        _oneof_case_{} {}

template <typename>
constexpr Controller::Controller(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL Controller::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) Controller(arena);
}
constexpr auto Controller::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Controller), alignof(Controller));
}
constexpr auto Controller::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &Controller::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<Controller>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &Controller::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<Controller>(), &Controller::ByteSizeLong,
              &Controller::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(Controller, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.Controller",
  };
}
struct ControllerGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr ControllerGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 Controller_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(Controller::InternalGenerateClassData_(
            _default, &Controller_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<Controller>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~ControllerGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) Controller _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<Controller>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(ControllerGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST ControllerGlobalsTypeInternal Controller_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* Controller_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return Controller_globals_.GetClassData();
#else
  return Controller_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class ControllerManager::_Internal {
 public:
  using HasBits = decltype(::std::declval<ControllerManager>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(ControllerManager, _impl_._has_bits_);
};

constexpr ControllerManager::ParseTableT_ ControllerManager::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(ControllerManager, _impl_._has_bits_),
      0, // no _extensions_
      3, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967288,  // skipmap
      offsetof(ParseTableT_, field_entries),
      3,  // num_field_entries
      1,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::ControllerManager>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // repeated .webrtc.audio_network_adaptor.config.Controller controllers = 1;
      {::_pbi::TcParser::FastMtR1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(ControllerManager, _impl_.controllers_)}},
      // optional int32 min_reordering_time_ms = 2;
      {::_pbi::TcParser::FastV32S1,
       {16, 1, 0,
        PROTOBUF_FIELD_OFFSET(ControllerManager, _impl_.min_reordering_time_ms_)}},
      // optional float min_reordering_squared_distance = 3;
      {::_pbi::TcParser::FastF32S1,
       {29, 2, 0,
        PROTOBUF_FIELD_OFFSET(ControllerManager, _impl_.min_reordering_squared_distance_)}},
    }}, {{
      65535, 65535
    }}, {{
      // repeated .webrtc.audio_network_adaptor.config.Controller controllers = 1;
      {PROTOBUF_FIELD_OFFSET(ControllerManager, _impl_.controllers_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional int32 min_reordering_time_ms = 2;
      {PROTOBUF_FIELD_OFFSET(ControllerManager, _impl_.min_reordering_time_ms_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional float min_reordering_squared_distance = 3;
      {PROTOBUF_FIELD_OFFSET(ControllerManager, _impl_.min_reordering_squared_distance_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::webrtc::audio_network_adaptor::config::Controller>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::webrtc::audio_network_adaptor::config::Controller_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr ControllerManager::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        controllers_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::webrtc::audio_network_adaptor::config::ControllerManager,
            PROTOBUF_FIELD_OFFSET(::webrtc::audio_network_adaptor::config::ControllerManager, _impl_.controllers_)>()
         }
        ,
        min_reordering_time_ms_{0},
        min_reordering_squared_distance_{0} {}

template <typename>
constexpr ControllerManager::ControllerManager(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL ControllerManager::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) ControllerManager(arena);
}
constexpr auto ControllerManager::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ControllerManager), alignof(ControllerManager));
}
constexpr auto ControllerManager::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &ControllerManager::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<ControllerManager>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &ControllerManager::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<ControllerManager>(), &ControllerManager::ByteSizeLong,
              &ControllerManager::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(ControllerManager, _impl_._cached_size_),
          true,
      },
      "webrtc.audio_network_adaptor.config.ControllerManager",
  };
}
struct ControllerManagerGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr ControllerManagerGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 ControllerManager_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(ControllerManager::InternalGenerateClassData_(
            _default, &ControllerManager_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<ControllerManager>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~ControllerManagerGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) ControllerManager _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<ControllerManager>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(ControllerManagerGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST ControllerManagerGlobalsTypeInternal ControllerManager_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* ControllerManager_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return ControllerManager_globals_.GetClassData();
#else
  return ControllerManager_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
}  // namespace config
}  // namespace audio_network_adaptor
}  // namespace webrtc
namespace webrtc {
namespace audio_network_adaptor {
namespace config {
// ===================================================================

FecController_Threshold::FecController_Threshold(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FecController_Threshold_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.FecController.Threshold)
}
FecController_Threshold::FecController_Threshold(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FecController_Threshold& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FecController_Threshold_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE FecController_Threshold::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void FecController_Threshold::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, low_bandwidth_bps_),
           0,
           offsetof(Impl_, high_bandwidth_packet_loss_) -
               offsetof(Impl_, low_bandwidth_bps_) +
               sizeof(Impl_::high_bandwidth_packet_loss_));
}
FecController_Threshold::~FecController_Threshold() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.FecController.Threshold)
  SharedDtor(*this);
}
inline void FecController_Threshold::SharedDtor(MessageLite& self) {
  FecController_Threshold& this_ = static_cast<FecController_Threshold&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite FecController_Threshold_class_data_ =
    FecController_Threshold::InternalGenerateClassData_(FecController_Threshold_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FecController_Threshold::GetClassData() const {
  return FecController_Threshold_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FecController_Threshold::GetClassData() const {
  return FecController_Threshold_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const FecController_Threshold::ParseTableT_
    FecController_Threshold::_table_ =
        FecController_Threshold::InternalGenerateParseTable_(FecController_Threshold_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void FecController_Threshold::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.FecController.Threshold)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    ::memset(&_impl_.low_bandwidth_bps_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.high_bandwidth_packet_loss_) -
        reinterpret_cast<char*>(&_impl_.low_bandwidth_bps_)) + sizeof(_impl_.high_bandwidth_packet_loss_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL FecController_Threshold::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const FecController_Threshold& this_ = static_cast<const FecController_Threshold&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL FecController_Threshold::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const FecController_Threshold& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.FecController.Threshold)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional int32 low_bandwidth_bps = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<1>(
            stream, this_._internal_low_bandwidth_bps(), target);
  }

  // optional float low_bandwidth_packet_loss = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        2, this_._internal_low_bandwidth_packet_loss(), target);
  }

  // optional int32 high_bandwidth_bps = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<3>(
            stream, this_._internal_high_bandwidth_bps(), target);
  }

  // optional float high_bandwidth_packet_loss = 4;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        4, this_._internal_high_bandwidth_packet_loss(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.FecController.Threshold)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t FecController_Threshold::ByteSizeLong(const MessageLite& base) {
  const FecController_Threshold& this_ = static_cast<const FecController_Threshold&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t FecController_Threshold::ByteSizeLong() const {
  const FecController_Threshold& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.FecController.Threshold)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += ::absl::popcount(0x0000000aU & cached_has_bits) * 5;
  if (BatchCheckHasBit(cached_has_bits, 0x00000005U)) {
    // optional int32 low_bandwidth_bps = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_low_bandwidth_bps());
    }
    // optional int32 high_bandwidth_bps = 3;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_high_bandwidth_bps());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void FecController_Threshold::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<FecController_Threshold*>(&to_msg);
  auto& from = static_cast<const FecController_Threshold&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.FecController.Threshold)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.low_bandwidth_bps_ = from._impl_.low_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.low_bandwidth_packet_loss_ = from._impl_.low_bandwidth_packet_loss_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.high_bandwidth_bps_ = from._impl_.high_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.high_bandwidth_packet_loss_ = from._impl_.high_bandwidth_packet_loss_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void FecController_Threshold::CopyFrom(const FecController_Threshold& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.FecController.Threshold)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void FecController_Threshold::InternalSwap(FecController_Threshold* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_.high_bandwidth_packet_loss_)
      + sizeof(FecController_Threshold::_impl_.high_bandwidth_packet_loss_)
      - PROTOBUF_FIELD_OFFSET(FecController_Threshold, _impl_.low_bandwidth_bps_)>(
          reinterpret_cast<char*>(&_impl_.low_bandwidth_bps_),
          reinterpret_cast<char*>(&other->_impl_.low_bandwidth_bps_));
}

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

FecController::FecController(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FecController_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.FecController)
}
PROTOBUF_NDEBUG_INLINE FecController::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::webrtc::audio_network_adaptor::config::FecController& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0} {}

FecController::FecController(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const FecController& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FecController_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  FecController* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.fec_enabling_threshold_ = (CheckHasBit(cached_has_bits, 0x00000001U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.fec_enabling_threshold_)
                : nullptr;
  _impl_.fec_disabling_threshold_ = (CheckHasBit(cached_has_bits, 0x00000002U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.fec_disabling_threshold_)
                : nullptr;
  _impl_.time_constant_ms_ = from._impl_.time_constant_ms_;

  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.FecController)
}
PROTOBUF_NDEBUG_INLINE FecController::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void FecController::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, fec_enabling_threshold_),
           0,
           offsetof(Impl_, time_constant_ms_) -
               offsetof(Impl_, fec_enabling_threshold_) +
               sizeof(Impl_::time_constant_ms_));
}
FecController::~FecController() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.FecController)
  SharedDtor(*this);
}
inline void FecController::SharedDtor(MessageLite& self) {
  FecController& this_ = static_cast<FecController&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.fec_enabling_threshold_;
  delete this_._impl_.fec_disabling_threshold_;
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite FecController_class_data_ =
    FecController::InternalGenerateClassData_(FecController_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FecController::GetClassData() const {
  return FecController_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FecController::GetClassData() const {
  return FecController_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const FecController::ParseTableT_
    FecController::_table_ =
        FecController::InternalGenerateParseTable_(FecController_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void FecController::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.FecController)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ABSL_DCHECK(_impl_.fec_enabling_threshold_ != nullptr);
      _impl_.fec_enabling_threshold_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(_impl_.fec_disabling_threshold_ != nullptr);
      _impl_.fec_disabling_threshold_->Clear();
    }
  }
  _impl_.time_constant_ms_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL FecController::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const FecController& this_ = static_cast<const FecController&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL FecController::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const FecController& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.FecController)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_enabling_threshold = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        1, *this_._impl_.fec_enabling_threshold_, this_._impl_.fec_enabling_threshold_->GetCachedSize(), target,
        stream);
  }

  // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_disabling_threshold = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        2, *this_._impl_.fec_disabling_threshold_, this_._impl_.fec_disabling_threshold_->GetCachedSize(), target,
        stream);
  }

  // optional int32 time_constant_ms = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<3>(
            stream, this_._internal_time_constant_ms(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.FecController)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t FecController::ByteSizeLong(const MessageLite& base) {
  const FecController& this_ = static_cast<const FecController&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t FecController::ByteSizeLong() const {
  const FecController& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.FecController)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_enabling_threshold = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.fec_enabling_threshold_);
    }
    // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_disabling_threshold = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.fec_disabling_threshold_);
    }
    // optional int32 time_constant_ms = 3;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_time_constant_ms());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void FecController::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<FecController*>(&to_msg);
  auto& from = static_cast<const FecController&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.FecController)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ABSL_DCHECK(from._impl_.fec_enabling_threshold_ != nullptr);
      if (_this->_impl_.fec_enabling_threshold_ == nullptr) {
        _this->_impl_.fec_enabling_threshold_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.fec_enabling_threshold_);
      } else {
        _this->_impl_.fec_enabling_threshold_->MergeFrom(*from._impl_.fec_enabling_threshold_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(from._impl_.fec_disabling_threshold_ != nullptr);
      if (_this->_impl_.fec_disabling_threshold_ == nullptr) {
        _this->_impl_.fec_disabling_threshold_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.fec_disabling_threshold_);
      } else {
        _this->_impl_.fec_disabling_threshold_->MergeFrom(*from._impl_.fec_disabling_threshold_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.time_constant_ms_ = from._impl_.time_constant_ms_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void FecController::CopyFrom(const FecController& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.FecController)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void FecController::InternalSwap(FecController* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FecController, _impl_.time_constant_ms_)
      + sizeof(FecController::_impl_.time_constant_ms_)
      - PROTOBUF_FIELD_OFFSET(FecController, _impl_.fec_enabling_threshold_)>(
          reinterpret_cast<char*>(&_impl_.fec_enabling_threshold_),
          reinterpret_cast<char*>(&other->_impl_.fec_enabling_threshold_));
}

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

FecControllerRplrBased_Threshold::FecControllerRplrBased_Threshold(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FecControllerRplrBased_Threshold_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
}
FecControllerRplrBased_Threshold::FecControllerRplrBased_Threshold(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FecControllerRplrBased_Threshold& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FecControllerRplrBased_Threshold_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE FecControllerRplrBased_Threshold::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void FecControllerRplrBased_Threshold::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, low_bandwidth_bps_),
           0,
           offsetof(Impl_, high_bandwidth_recoverable_packet_loss_) -
               offsetof(Impl_, low_bandwidth_bps_) +
               sizeof(Impl_::high_bandwidth_recoverable_packet_loss_));
}
FecControllerRplrBased_Threshold::~FecControllerRplrBased_Threshold() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  SharedDtor(*this);
}
inline void FecControllerRplrBased_Threshold::SharedDtor(MessageLite& self) {
  FecControllerRplrBased_Threshold& this_ = static_cast<FecControllerRplrBased_Threshold&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite FecControllerRplrBased_Threshold_class_data_ =
    FecControllerRplrBased_Threshold::InternalGenerateClassData_(FecControllerRplrBased_Threshold_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FecControllerRplrBased_Threshold::GetClassData() const {
  return FecControllerRplrBased_Threshold_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FecControllerRplrBased_Threshold::GetClassData() const {
  return FecControllerRplrBased_Threshold_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const FecControllerRplrBased_Threshold::ParseTableT_
    FecControllerRplrBased_Threshold::_table_ =
        FecControllerRplrBased_Threshold::InternalGenerateParseTable_(FecControllerRplrBased_Threshold_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void FecControllerRplrBased_Threshold::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    ::memset(&_impl_.low_bandwidth_bps_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.high_bandwidth_recoverable_packet_loss_) -
        reinterpret_cast<char*>(&_impl_.low_bandwidth_bps_)) + sizeof(_impl_.high_bandwidth_recoverable_packet_loss_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL FecControllerRplrBased_Threshold::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const FecControllerRplrBased_Threshold& this_ = static_cast<const FecControllerRplrBased_Threshold&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL FecControllerRplrBased_Threshold::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const FecControllerRplrBased_Threshold& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional int32 low_bandwidth_bps = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<1>(
            stream, this_._internal_low_bandwidth_bps(), target);
  }

  // optional float low_bandwidth_recoverable_packet_loss = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        2, this_._internal_low_bandwidth_recoverable_packet_loss(), target);
  }

  // optional int32 high_bandwidth_bps = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<3>(
            stream, this_._internal_high_bandwidth_bps(), target);
  }

  // optional float high_bandwidth_recoverable_packet_loss = 4;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        4, this_._internal_high_bandwidth_recoverable_packet_loss(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t FecControllerRplrBased_Threshold::ByteSizeLong(const MessageLite& base) {
  const FecControllerRplrBased_Threshold& this_ = static_cast<const FecControllerRplrBased_Threshold&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t FecControllerRplrBased_Threshold::ByteSizeLong() const {
  const FecControllerRplrBased_Threshold& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += ::absl::popcount(0x0000000aU & cached_has_bits) * 5;
  if (BatchCheckHasBit(cached_has_bits, 0x00000005U)) {
    // optional int32 low_bandwidth_bps = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_low_bandwidth_bps());
    }
    // optional int32 high_bandwidth_bps = 3;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_high_bandwidth_bps());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void FecControllerRplrBased_Threshold::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<FecControllerRplrBased_Threshold*>(&to_msg);
  auto& from = static_cast<const FecControllerRplrBased_Threshold&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.low_bandwidth_bps_ = from._impl_.low_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.low_bandwidth_recoverable_packet_loss_ = from._impl_.low_bandwidth_recoverable_packet_loss_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.high_bandwidth_bps_ = from._impl_.high_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.high_bandwidth_recoverable_packet_loss_ = from._impl_.high_bandwidth_recoverable_packet_loss_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void FecControllerRplrBased_Threshold::CopyFrom(const FecControllerRplrBased_Threshold& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void FecControllerRplrBased_Threshold::InternalSwap(FecControllerRplrBased_Threshold* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_.high_bandwidth_recoverable_packet_loss_)
      + sizeof(FecControllerRplrBased_Threshold::_impl_.high_bandwidth_recoverable_packet_loss_)
      - PROTOBUF_FIELD_OFFSET(FecControllerRplrBased_Threshold, _impl_.low_bandwidth_bps_)>(
          reinterpret_cast<char*>(&_impl_.low_bandwidth_bps_),
          reinterpret_cast<char*>(&other->_impl_.low_bandwidth_bps_));
}

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

FecControllerRplrBased::FecControllerRplrBased(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FecControllerRplrBased_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
}
PROTOBUF_NDEBUG_INLINE FecControllerRplrBased::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::webrtc::audio_network_adaptor::config::FecControllerRplrBased& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0} {}

FecControllerRplrBased::FecControllerRplrBased(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const FecControllerRplrBased& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FecControllerRplrBased_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  FecControllerRplrBased* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.fec_enabling_threshold_ = (CheckHasBit(cached_has_bits, 0x00000001U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.fec_enabling_threshold_)
                : nullptr;
  _impl_.fec_disabling_threshold_ = (CheckHasBit(cached_has_bits, 0x00000002U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.fec_disabling_threshold_)
                : nullptr;

  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
}
PROTOBUF_NDEBUG_INLINE FecControllerRplrBased::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void FecControllerRplrBased::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, fec_enabling_threshold_),
           0,
           offsetof(Impl_, fec_disabling_threshold_) -
               offsetof(Impl_, fec_enabling_threshold_) +
               sizeof(Impl_::fec_disabling_threshold_));
}
FecControllerRplrBased::~FecControllerRplrBased() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  SharedDtor(*this);
}
inline void FecControllerRplrBased::SharedDtor(MessageLite& self) {
  FecControllerRplrBased& this_ = static_cast<FecControllerRplrBased&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.fec_enabling_threshold_;
  delete this_._impl_.fec_disabling_threshold_;
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite FecControllerRplrBased_class_data_ =
    FecControllerRplrBased::InternalGenerateClassData_(FecControllerRplrBased_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FecControllerRplrBased::GetClassData() const {
  return FecControllerRplrBased_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FecControllerRplrBased::GetClassData() const {
  return FecControllerRplrBased_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const FecControllerRplrBased::ParseTableT_
    FecControllerRplrBased::_table_ =
        FecControllerRplrBased::InternalGenerateParseTable_(FecControllerRplrBased_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void FecControllerRplrBased::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ABSL_DCHECK(_impl_.fec_enabling_threshold_ != nullptr);
      _impl_.fec_enabling_threshold_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(_impl_.fec_disabling_threshold_ != nullptr);
      _impl_.fec_disabling_threshold_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL FecControllerRplrBased::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const FecControllerRplrBased& this_ = static_cast<const FecControllerRplrBased&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL FecControllerRplrBased::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const FecControllerRplrBased& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_enabling_threshold = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        1, *this_._impl_.fec_enabling_threshold_, this_._impl_.fec_enabling_threshold_->GetCachedSize(), target,
        stream);
  }

  // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_disabling_threshold = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        2, *this_._impl_.fec_disabling_threshold_, this_._impl_.fec_disabling_threshold_->GetCachedSize(), target,
        stream);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t FecControllerRplrBased::ByteSizeLong(const MessageLite& base) {
  const FecControllerRplrBased& this_ = static_cast<const FecControllerRplrBased&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t FecControllerRplrBased::ByteSizeLong() const {
  const FecControllerRplrBased& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_enabling_threshold = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.fec_enabling_threshold_);
    }
    // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_disabling_threshold = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.fec_disabling_threshold_);
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void FecControllerRplrBased::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<FecControllerRplrBased*>(&to_msg);
  auto& from = static_cast<const FecControllerRplrBased&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ABSL_DCHECK(from._impl_.fec_enabling_threshold_ != nullptr);
      if (_this->_impl_.fec_enabling_threshold_ == nullptr) {
        _this->_impl_.fec_enabling_threshold_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.fec_enabling_threshold_);
      } else {
        _this->_impl_.fec_enabling_threshold_->MergeFrom(*from._impl_.fec_enabling_threshold_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(from._impl_.fec_disabling_threshold_ != nullptr);
      if (_this->_impl_.fec_disabling_threshold_ == nullptr) {
        _this->_impl_.fec_disabling_threshold_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.fec_disabling_threshold_);
      } else {
        _this->_impl_.fec_disabling_threshold_->MergeFrom(*from._impl_.fec_disabling_threshold_);
      }
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void FecControllerRplrBased::CopyFrom(const FecControllerRplrBased& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void FecControllerRplrBased::InternalSwap(FecControllerRplrBased* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FecControllerRplrBased, _impl_.fec_disabling_threshold_)
      + sizeof(FecControllerRplrBased::_impl_.fec_disabling_threshold_)
      - PROTOBUF_FIELD_OFFSET(FecControllerRplrBased, _impl_.fec_enabling_threshold_)>(
          reinterpret_cast<char*>(&_impl_.fec_enabling_threshold_),
          reinterpret_cast<char*>(&other->_impl_.fec_enabling_threshold_));
}

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

FrameLengthController::FrameLengthController(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FrameLengthController_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.FrameLengthController)
}
FrameLengthController::FrameLengthController(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FrameLengthController& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FrameLengthController_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE FrameLengthController::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void FrameLengthController::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, fl_increasing_packet_loss_fraction_),
           0,
           offsetof(Impl_, fl_60ms_to_40ms_bandwidth_bps_) -
               offsetof(Impl_, fl_increasing_packet_loss_fraction_) +
               sizeof(Impl_::fl_60ms_to_40ms_bandwidth_bps_));
}
FrameLengthController::~FrameLengthController() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.FrameLengthController)
  SharedDtor(*this);
}
inline void FrameLengthController::SharedDtor(MessageLite& self) {
  FrameLengthController& this_ = static_cast<FrameLengthController&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite FrameLengthController_class_data_ =
    FrameLengthController::InternalGenerateClassData_(FrameLengthController_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FrameLengthController::GetClassData() const {
  return FrameLengthController_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FrameLengthController::GetClassData() const {
  return FrameLengthController_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const FrameLengthController::ParseTableT_
    FrameLengthController::_table_ =
        FrameLengthController::InternalGenerateParseTable_(FrameLengthController_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void FrameLengthController::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.FrameLengthController)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    ::memset(&_impl_.fl_increasing_packet_loss_fraction_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.fl_decrease_overhead_offset_) -
        reinterpret_cast<char*>(&_impl_.fl_increasing_packet_loss_fraction_)) + sizeof(_impl_.fl_decrease_overhead_offset_));
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00000f00U)) {
    ::memset(&_impl_.fl_20ms_to_40ms_bandwidth_bps_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.fl_60ms_to_40ms_bandwidth_bps_) -
        reinterpret_cast<char*>(&_impl_.fl_20ms_to_40ms_bandwidth_bps_)) + sizeof(_impl_.fl_60ms_to_40ms_bandwidth_bps_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL FrameLengthController::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const FrameLengthController& this_ = static_cast<const FrameLengthController&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL FrameLengthController::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const FrameLengthController& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.FrameLengthController)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional float fl_increasing_packet_loss_fraction = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        1, this_._internal_fl_increasing_packet_loss_fraction(), target);
  }

  // optional float fl_decreasing_packet_loss_fraction = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        2, this_._internal_fl_decreasing_packet_loss_fraction(), target);
  }

  // optional int32 fl_20ms_to_60ms_bandwidth_bps = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<3>(
            stream, this_._internal_fl_20ms_to_60ms_bandwidth_bps(), target);
  }

  // optional int32 fl_60ms_to_20ms_bandwidth_bps = 4;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<4>(
            stream, this_._internal_fl_60ms_to_20ms_bandwidth_bps(), target);
  }

  // optional int32 fl_60ms_to_120ms_bandwidth_bps = 5;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<5>(
            stream, this_._internal_fl_60ms_to_120ms_bandwidth_bps(), target);
  }

  // optional int32 fl_120ms_to_60ms_bandwidth_bps = 6;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<6>(
            stream, this_._internal_fl_120ms_to_60ms_bandwidth_bps(), target);
  }

  // optional int32 fl_increase_overhead_offset = 7;
  if (CheckHasBit(cached_has_bits, 0x00000040U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<7>(
            stream, this_._internal_fl_increase_overhead_offset(), target);
  }

  // optional int32 fl_decrease_overhead_offset = 8;
  if (CheckHasBit(cached_has_bits, 0x00000080U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<8>(
            stream, this_._internal_fl_decrease_overhead_offset(), target);
  }

  // optional int32 fl_20ms_to_40ms_bandwidth_bps = 9;
  if (CheckHasBit(cached_has_bits, 0x00000100U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<9>(
            stream, this_._internal_fl_20ms_to_40ms_bandwidth_bps(), target);
  }

  // optional int32 fl_40ms_to_20ms_bandwidth_bps = 10;
  if (CheckHasBit(cached_has_bits, 0x00000200U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<10>(
            stream, this_._internal_fl_40ms_to_20ms_bandwidth_bps(), target);
  }

  // optional int32 fl_40ms_to_60ms_bandwidth_bps = 11;
  if (CheckHasBit(cached_has_bits, 0x00000400U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<11>(
            stream, this_._internal_fl_40ms_to_60ms_bandwidth_bps(), target);
  }

  // optional int32 fl_60ms_to_40ms_bandwidth_bps = 12;
  if (CheckHasBit(cached_has_bits, 0x00000800U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<12>(
            stream, this_._internal_fl_60ms_to_40ms_bandwidth_bps(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.FrameLengthController)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t FrameLengthController::ByteSizeLong(const MessageLite& base) {
  const FrameLengthController& this_ = static_cast<const FrameLengthController&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t FrameLengthController::ByteSizeLong() const {
  const FrameLengthController& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.FrameLengthController)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += ::absl::popcount(0x00000003U & cached_has_bits) * 5;
  if (BatchCheckHasBit(cached_has_bits, 0x000000fcU)) {
    // optional int32 fl_20ms_to_60ms_bandwidth_bps = 3;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_20ms_to_60ms_bandwidth_bps());
    }
    // optional int32 fl_60ms_to_20ms_bandwidth_bps = 4;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_60ms_to_20ms_bandwidth_bps());
    }
    // optional int32 fl_60ms_to_120ms_bandwidth_bps = 5;
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_60ms_to_120ms_bandwidth_bps());
    }
    // optional int32 fl_120ms_to_60ms_bandwidth_bps = 6;
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_120ms_to_60ms_bandwidth_bps());
    }
    // optional int32 fl_increase_overhead_offset = 7;
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_increase_overhead_offset());
    }
    // optional int32 fl_decrease_overhead_offset = 8;
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_decrease_overhead_offset());
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00000f00U)) {
    // optional int32 fl_20ms_to_40ms_bandwidth_bps = 9;
    if (CheckHasBit(cached_has_bits, 0x00000100U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_20ms_to_40ms_bandwidth_bps());
    }
    // optional int32 fl_40ms_to_20ms_bandwidth_bps = 10;
    if (CheckHasBit(cached_has_bits, 0x00000200U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_40ms_to_20ms_bandwidth_bps());
    }
    // optional int32 fl_40ms_to_60ms_bandwidth_bps = 11;
    if (CheckHasBit(cached_has_bits, 0x00000400U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_40ms_to_60ms_bandwidth_bps());
    }
    // optional int32 fl_60ms_to_40ms_bandwidth_bps = 12;
    if (CheckHasBit(cached_has_bits, 0x00000800U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_60ms_to_40ms_bandwidth_bps());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void FrameLengthController::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<FrameLengthController*>(&to_msg);
  auto& from = static_cast<const FrameLengthController&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.FrameLengthController)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.fl_increasing_packet_loss_fraction_ = from._impl_.fl_increasing_packet_loss_fraction_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.fl_decreasing_packet_loss_fraction_ = from._impl_.fl_decreasing_packet_loss_fraction_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.fl_20ms_to_60ms_bandwidth_bps_ = from._impl_.fl_20ms_to_60ms_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.fl_60ms_to_20ms_bandwidth_bps_ = from._impl_.fl_60ms_to_20ms_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.fl_60ms_to_120ms_bandwidth_bps_ = from._impl_.fl_60ms_to_120ms_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      _this->_impl_.fl_120ms_to_60ms_bandwidth_bps_ = from._impl_.fl_120ms_to_60ms_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      _this->_impl_.fl_increase_overhead_offset_ = from._impl_.fl_increase_overhead_offset_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      _this->_impl_.fl_decrease_overhead_offset_ = from._impl_.fl_decrease_overhead_offset_;
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00000f00U)) {
    if (CheckHasBit(cached_has_bits, 0x00000100U)) {
      _this->_impl_.fl_20ms_to_40ms_bandwidth_bps_ = from._impl_.fl_20ms_to_40ms_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000200U)) {
      _this->_impl_.fl_40ms_to_20ms_bandwidth_bps_ = from._impl_.fl_40ms_to_20ms_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000400U)) {
      _this->_impl_.fl_40ms_to_60ms_bandwidth_bps_ = from._impl_.fl_40ms_to_60ms_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000800U)) {
      _this->_impl_.fl_60ms_to_40ms_bandwidth_bps_ = from._impl_.fl_60ms_to_40ms_bandwidth_bps_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void FrameLengthController::CopyFrom(const FrameLengthController& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.FrameLengthController)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void FrameLengthController::InternalSwap(FrameLengthController* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_60ms_to_40ms_bandwidth_bps_)
      + sizeof(FrameLengthController::_impl_.fl_60ms_to_40ms_bandwidth_bps_)
      - PROTOBUF_FIELD_OFFSET(FrameLengthController, _impl_.fl_increasing_packet_loss_fraction_)>(
          reinterpret_cast<char*>(&_impl_.fl_increasing_packet_loss_fraction_),
          reinterpret_cast<char*>(&other->_impl_.fl_increasing_packet_loss_fraction_));
}

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

FrameLengthControllerV2::FrameLengthControllerV2(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FrameLengthControllerV2_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.FrameLengthControllerV2)
}
FrameLengthControllerV2::FrameLengthControllerV2(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FrameLengthControllerV2& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FrameLengthControllerV2_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE FrameLengthControllerV2::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void FrameLengthControllerV2::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, min_payload_bitrate_bps_),
           0,
           offsetof(Impl_, use_slow_adaptation_) -
               offsetof(Impl_, min_payload_bitrate_bps_) +
               sizeof(Impl_::use_slow_adaptation_));
}
FrameLengthControllerV2::~FrameLengthControllerV2() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.FrameLengthControllerV2)
  SharedDtor(*this);
}
inline void FrameLengthControllerV2::SharedDtor(MessageLite& self) {
  FrameLengthControllerV2& this_ = static_cast<FrameLengthControllerV2&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite FrameLengthControllerV2_class_data_ =
    FrameLengthControllerV2::InternalGenerateClassData_(FrameLengthControllerV2_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FrameLengthControllerV2::GetClassData() const {
  return FrameLengthControllerV2_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FrameLengthControllerV2::GetClassData() const {
  return FrameLengthControllerV2_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const FrameLengthControllerV2::ParseTableT_
    FrameLengthControllerV2::_table_ =
        FrameLengthControllerV2::InternalGenerateParseTable_(FrameLengthControllerV2_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void FrameLengthControllerV2::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.FrameLengthControllerV2)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    ::memset(&_impl_.min_payload_bitrate_bps_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.use_slow_adaptation_) -
        reinterpret_cast<char*>(&_impl_.min_payload_bitrate_bps_)) + sizeof(_impl_.use_slow_adaptation_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL FrameLengthControllerV2::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const FrameLengthControllerV2& this_ = static_cast<const FrameLengthControllerV2&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL FrameLengthControllerV2::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const FrameLengthControllerV2& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.FrameLengthControllerV2)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional int32 min_payload_bitrate_bps = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<1>(
            stream, this_._internal_min_payload_bitrate_bps(), target);
  }

  // optional bool use_slow_adaptation = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        2, this_._internal_use_slow_adaptation(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.FrameLengthControllerV2)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t FrameLengthControllerV2::ByteSizeLong(const MessageLite& base) {
  const FrameLengthControllerV2& this_ = static_cast<const FrameLengthControllerV2&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t FrameLengthControllerV2::ByteSizeLong() const {
  const FrameLengthControllerV2& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.FrameLengthControllerV2)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += static_cast<bool>(0x00000002U & cached_has_bits) * 2;
   {
    // optional int32 min_payload_bitrate_bps = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_min_payload_bitrate_bps());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void FrameLengthControllerV2::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<FrameLengthControllerV2*>(&to_msg);
  auto& from = static_cast<const FrameLengthControllerV2&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.FrameLengthControllerV2)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.min_payload_bitrate_bps_ = from._impl_.min_payload_bitrate_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.use_slow_adaptation_ = from._impl_.use_slow_adaptation_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void FrameLengthControllerV2::CopyFrom(const FrameLengthControllerV2& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.FrameLengthControllerV2)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void FrameLengthControllerV2::InternalSwap(FrameLengthControllerV2* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FrameLengthControllerV2, _impl_.use_slow_adaptation_)
      + sizeof(FrameLengthControllerV2::_impl_.use_slow_adaptation_)
      - PROTOBUF_FIELD_OFFSET(FrameLengthControllerV2, _impl_.min_payload_bitrate_bps_)>(
          reinterpret_cast<char*>(&_impl_.min_payload_bitrate_bps_),
          reinterpret_cast<char*>(&other->_impl_.min_payload_bitrate_bps_));
}

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

ChannelController::ChannelController(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, ChannelController_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.ChannelController)
}
ChannelController::ChannelController(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ChannelController& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, ChannelController_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE ChannelController::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void ChannelController::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, channel_1_to_2_bandwidth_bps_),
           0,
           offsetof(Impl_, channel_2_to_1_bandwidth_bps_) -
               offsetof(Impl_, channel_1_to_2_bandwidth_bps_) +
               sizeof(Impl_::channel_2_to_1_bandwidth_bps_));
}
ChannelController::~ChannelController() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.ChannelController)
  SharedDtor(*this);
}
inline void ChannelController::SharedDtor(MessageLite& self) {
  ChannelController& this_ = static_cast<ChannelController&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite ChannelController_class_data_ =
    ChannelController::InternalGenerateClassData_(ChannelController_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
ChannelController::GetClassData() const {
  return ChannelController_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
ChannelController::GetClassData() const {
  return ChannelController_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ChannelController::ParseTableT_
    ChannelController::_table_ =
        ChannelController::InternalGenerateParseTable_(ChannelController_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void ChannelController::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.ChannelController)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    ::memset(&_impl_.channel_1_to_2_bandwidth_bps_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.channel_2_to_1_bandwidth_bps_) -
        reinterpret_cast<char*>(&_impl_.channel_1_to_2_bandwidth_bps_)) + sizeof(_impl_.channel_2_to_1_bandwidth_bps_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL ChannelController::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const ChannelController& this_ = static_cast<const ChannelController&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL ChannelController::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const ChannelController& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.ChannelController)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional int32 channel_1_to_2_bandwidth_bps = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<1>(
            stream, this_._internal_channel_1_to_2_bandwidth_bps(), target);
  }

  // optional int32 channel_2_to_1_bandwidth_bps = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>(
            stream, this_._internal_channel_2_to_1_bandwidth_bps(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.ChannelController)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t ChannelController::ByteSizeLong(const MessageLite& base) {
  const ChannelController& this_ = static_cast<const ChannelController&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t ChannelController::ByteSizeLong() const {
  const ChannelController& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.ChannelController)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // optional int32 channel_1_to_2_bandwidth_bps = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_channel_1_to_2_bandwidth_bps());
    }
    // optional int32 channel_2_to_1_bandwidth_bps = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_channel_2_to_1_bandwidth_bps());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void ChannelController::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<ChannelController*>(&to_msg);
  auto& from = static_cast<const ChannelController&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.ChannelController)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.channel_1_to_2_bandwidth_bps_ = from._impl_.channel_1_to_2_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.channel_2_to_1_bandwidth_bps_ = from._impl_.channel_2_to_1_bandwidth_bps_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void ChannelController::CopyFrom(const ChannelController& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.ChannelController)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void ChannelController::InternalSwap(ChannelController* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ChannelController, _impl_.channel_2_to_1_bandwidth_bps_)
      + sizeof(ChannelController::_impl_.channel_2_to_1_bandwidth_bps_)
      - PROTOBUF_FIELD_OFFSET(ChannelController, _impl_.channel_1_to_2_bandwidth_bps_)>(
          reinterpret_cast<char*>(&_impl_.channel_1_to_2_bandwidth_bps_),
          reinterpret_cast<char*>(&other->_impl_.channel_1_to_2_bandwidth_bps_));
}

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

DtxController::DtxController(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, DtxController_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.DtxController)
}
DtxController::DtxController(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DtxController& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, DtxController_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE DtxController::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void DtxController::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, dtx_enabling_bandwidth_bps_),
           0,
           offsetof(Impl_, dtx_disabling_bandwidth_bps_) -
               offsetof(Impl_, dtx_enabling_bandwidth_bps_) +
               sizeof(Impl_::dtx_disabling_bandwidth_bps_));
}
DtxController::~DtxController() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.DtxController)
  SharedDtor(*this);
}
inline void DtxController::SharedDtor(MessageLite& self) {
  DtxController& this_ = static_cast<DtxController&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite DtxController_class_data_ =
    DtxController::InternalGenerateClassData_(DtxController_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
DtxController::GetClassData() const {
  return DtxController_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
DtxController::GetClassData() const {
  return DtxController_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const DtxController::ParseTableT_
    DtxController::_table_ =
        DtxController::InternalGenerateParseTable_(DtxController_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void DtxController::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.DtxController)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    ::memset(&_impl_.dtx_enabling_bandwidth_bps_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.dtx_disabling_bandwidth_bps_) -
        reinterpret_cast<char*>(&_impl_.dtx_enabling_bandwidth_bps_)) + sizeof(_impl_.dtx_disabling_bandwidth_bps_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL DtxController::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const DtxController& this_ = static_cast<const DtxController&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL DtxController::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const DtxController& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.DtxController)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional int32 dtx_enabling_bandwidth_bps = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<1>(
            stream, this_._internal_dtx_enabling_bandwidth_bps(), target);
  }

  // optional int32 dtx_disabling_bandwidth_bps = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>(
            stream, this_._internal_dtx_disabling_bandwidth_bps(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.DtxController)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t DtxController::ByteSizeLong(const MessageLite& base) {
  const DtxController& this_ = static_cast<const DtxController&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t DtxController::ByteSizeLong() const {
  const DtxController& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.DtxController)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // optional int32 dtx_enabling_bandwidth_bps = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_dtx_enabling_bandwidth_bps());
    }
    // optional int32 dtx_disabling_bandwidth_bps = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_dtx_disabling_bandwidth_bps());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void DtxController::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<DtxController*>(&to_msg);
  auto& from = static_cast<const DtxController&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.DtxController)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.dtx_enabling_bandwidth_bps_ = from._impl_.dtx_enabling_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.dtx_disabling_bandwidth_bps_ = from._impl_.dtx_disabling_bandwidth_bps_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void DtxController::CopyFrom(const DtxController& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.DtxController)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void DtxController::InternalSwap(DtxController* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DtxController, _impl_.dtx_disabling_bandwidth_bps_)
      + sizeof(DtxController::_impl_.dtx_disabling_bandwidth_bps_)
      - PROTOBUF_FIELD_OFFSET(DtxController, _impl_.dtx_enabling_bandwidth_bps_)>(
          reinterpret_cast<char*>(&_impl_.dtx_enabling_bandwidth_bps_),
          reinterpret_cast<char*>(&other->_impl_.dtx_enabling_bandwidth_bps_));
}

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

BitrateController::BitrateController(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, BitrateController_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.BitrateController)
}
BitrateController::BitrateController(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const BitrateController& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, BitrateController_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE BitrateController::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void BitrateController::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, fl_increase_overhead_offset_),
           0,
           offsetof(Impl_, fl_decrease_overhead_offset_) -
               offsetof(Impl_, fl_increase_overhead_offset_) +
               sizeof(Impl_::fl_decrease_overhead_offset_));
}
BitrateController::~BitrateController() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.BitrateController)
  SharedDtor(*this);
}
inline void BitrateController::SharedDtor(MessageLite& self) {
  BitrateController& this_ = static_cast<BitrateController&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite BitrateController_class_data_ =
    BitrateController::InternalGenerateClassData_(BitrateController_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
BitrateController::GetClassData() const {
  return BitrateController_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
BitrateController::GetClassData() const {
  return BitrateController_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const BitrateController::ParseTableT_
    BitrateController::_table_ =
        BitrateController::InternalGenerateParseTable_(BitrateController_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void BitrateController::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.BitrateController)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    ::memset(&_impl_.fl_increase_overhead_offset_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.fl_decrease_overhead_offset_) -
        reinterpret_cast<char*>(&_impl_.fl_increase_overhead_offset_)) + sizeof(_impl_.fl_decrease_overhead_offset_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL BitrateController::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const BitrateController& this_ = static_cast<const BitrateController&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL BitrateController::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const BitrateController& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.BitrateController)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional int32 fl_increase_overhead_offset = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<1>(
            stream, this_._internal_fl_increase_overhead_offset(), target);
  }

  // optional int32 fl_decrease_overhead_offset = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>(
            stream, this_._internal_fl_decrease_overhead_offset(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.BitrateController)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t BitrateController::ByteSizeLong(const MessageLite& base) {
  const BitrateController& this_ = static_cast<const BitrateController&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t BitrateController::ByteSizeLong() const {
  const BitrateController& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.BitrateController)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // optional int32 fl_increase_overhead_offset = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_increase_overhead_offset());
    }
    // optional int32 fl_decrease_overhead_offset = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_fl_decrease_overhead_offset());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void BitrateController::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<BitrateController*>(&to_msg);
  auto& from = static_cast<const BitrateController&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.BitrateController)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.fl_increase_overhead_offset_ = from._impl_.fl_increase_overhead_offset_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.fl_decrease_overhead_offset_ = from._impl_.fl_decrease_overhead_offset_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void BitrateController::CopyFrom(const BitrateController& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.BitrateController)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void BitrateController::InternalSwap(BitrateController* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BitrateController, _impl_.fl_decrease_overhead_offset_)
      + sizeof(BitrateController::_impl_.fl_decrease_overhead_offset_)
      - PROTOBUF_FIELD_OFFSET(BitrateController, _impl_.fl_increase_overhead_offset_)>(
          reinterpret_cast<char*>(&_impl_.fl_increase_overhead_offset_),
          reinterpret_cast<char*>(&other->_impl_.fl_increase_overhead_offset_));
}

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

Controller_ScoringPoint::Controller_ScoringPoint(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, Controller_ScoringPoint_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
}
Controller_ScoringPoint::Controller_ScoringPoint(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Controller_ScoringPoint& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, Controller_ScoringPoint_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE Controller_ScoringPoint::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void Controller_ScoringPoint::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, uplink_bandwidth_bps_),
           0,
           offsetof(Impl_, uplink_packet_loss_fraction_) -
               offsetof(Impl_, uplink_bandwidth_bps_) +
               sizeof(Impl_::uplink_packet_loss_fraction_));
}
Controller_ScoringPoint::~Controller_ScoringPoint() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  SharedDtor(*this);
}
inline void Controller_ScoringPoint::SharedDtor(MessageLite& self) {
  Controller_ScoringPoint& this_ = static_cast<Controller_ScoringPoint&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite Controller_ScoringPoint_class_data_ =
    Controller_ScoringPoint::InternalGenerateClassData_(Controller_ScoringPoint_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
Controller_ScoringPoint::GetClassData() const {
  return Controller_ScoringPoint_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
Controller_ScoringPoint::GetClassData() const {
  return Controller_ScoringPoint_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const Controller_ScoringPoint::ParseTableT_
    Controller_ScoringPoint::_table_ =
        Controller_ScoringPoint::InternalGenerateParseTable_(Controller_ScoringPoint_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void Controller_ScoringPoint::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    ::memset(&_impl_.uplink_bandwidth_bps_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.uplink_packet_loss_fraction_) -
        reinterpret_cast<char*>(&_impl_.uplink_bandwidth_bps_)) + sizeof(_impl_.uplink_packet_loss_fraction_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL Controller_ScoringPoint::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const Controller_ScoringPoint& this_ = static_cast<const Controller_ScoringPoint&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL Controller_ScoringPoint::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const Controller_ScoringPoint& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional int32 uplink_bandwidth_bps = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<1>(
            stream, this_._internal_uplink_bandwidth_bps(), target);
  }

  // optional float uplink_packet_loss_fraction = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        2, this_._internal_uplink_packet_loss_fraction(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t Controller_ScoringPoint::ByteSizeLong(const MessageLite& base) {
  const Controller_ScoringPoint& this_ = static_cast<const Controller_ScoringPoint&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t Controller_ScoringPoint::ByteSizeLong() const {
  const Controller_ScoringPoint& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += static_cast<bool>(0x00000002U & cached_has_bits) * 5;
   {
    // optional int32 uplink_bandwidth_bps = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_uplink_bandwidth_bps());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void Controller_ScoringPoint::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<Controller_ScoringPoint*>(&to_msg);
  auto& from = static_cast<const Controller_ScoringPoint&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.uplink_bandwidth_bps_ = from._impl_.uplink_bandwidth_bps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.uplink_packet_loss_fraction_ = from._impl_.uplink_packet_loss_fraction_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void Controller_ScoringPoint::CopyFrom(const Controller_ScoringPoint& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void Controller_ScoringPoint::InternalSwap(Controller_ScoringPoint* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Controller_ScoringPoint, _impl_.uplink_packet_loss_fraction_)
      + sizeof(Controller_ScoringPoint::_impl_.uplink_packet_loss_fraction_)
      - PROTOBUF_FIELD_OFFSET(Controller_ScoringPoint, _impl_.uplink_bandwidth_bps_)>(
          reinterpret_cast<char*>(&_impl_.uplink_bandwidth_bps_),
          reinterpret_cast<char*>(&other->_impl_.uplink_bandwidth_bps_));
}

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

void Controller::set_allocated_fec_controller(::webrtc::audio_network_adaptor::config::FecController* PROTOBUF_NULLABLE fec_controller) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_controller();
  if (fec_controller) {
    ::google::protobuf::Arena* submessage_arena = fec_controller->GetArena();
    if (message_arena != submessage_arena) {
      fec_controller = ::google::protobuf::internal::GetOwnedMessage(message_arena, fec_controller, submessage_arena);
    }
    set_has_fec_controller();
    _impl_.controller_.fec_controller_ = fec_controller;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.fec_controller)
}
void Controller::set_allocated_frame_length_controller(::webrtc::audio_network_adaptor::config::FrameLengthController* PROTOBUF_NULLABLE frame_length_controller) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_controller();
  if (frame_length_controller) {
    ::google::protobuf::Arena* submessage_arena = frame_length_controller->GetArena();
    if (message_arena != submessage_arena) {
      frame_length_controller = ::google::protobuf::internal::GetOwnedMessage(message_arena, frame_length_controller, submessage_arena);
    }
    set_has_frame_length_controller();
    _impl_.controller_.frame_length_controller_ = frame_length_controller;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.frame_length_controller)
}
void Controller::set_allocated_channel_controller(::webrtc::audio_network_adaptor::config::ChannelController* PROTOBUF_NULLABLE channel_controller) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_controller();
  if (channel_controller) {
    ::google::protobuf::Arena* submessage_arena = channel_controller->GetArena();
    if (message_arena != submessage_arena) {
      channel_controller = ::google::protobuf::internal::GetOwnedMessage(message_arena, channel_controller, submessage_arena);
    }
    set_has_channel_controller();
    _impl_.controller_.channel_controller_ = channel_controller;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.channel_controller)
}
void Controller::set_allocated_dtx_controller(::webrtc::audio_network_adaptor::config::DtxController* PROTOBUF_NULLABLE dtx_controller) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_controller();
  if (dtx_controller) {
    ::google::protobuf::Arena* submessage_arena = dtx_controller->GetArena();
    if (message_arena != submessage_arena) {
      dtx_controller = ::google::protobuf::internal::GetOwnedMessage(message_arena, dtx_controller, submessage_arena);
    }
    set_has_dtx_controller();
    _impl_.controller_.dtx_controller_ = dtx_controller;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.dtx_controller)
}
void Controller::set_allocated_bitrate_controller(::webrtc::audio_network_adaptor::config::BitrateController* PROTOBUF_NULLABLE bitrate_controller) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_controller();
  if (bitrate_controller) {
    ::google::protobuf::Arena* submessage_arena = bitrate_controller->GetArena();
    if (message_arena != submessage_arena) {
      bitrate_controller = ::google::protobuf::internal::GetOwnedMessage(message_arena, bitrate_controller, submessage_arena);
    }
    set_has_bitrate_controller();
    _impl_.controller_.bitrate_controller_ = bitrate_controller;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.bitrate_controller)
}
void Controller::set_allocated_fec_controller_rplr_based(::webrtc::audio_network_adaptor::config::FecControllerRplrBased* PROTOBUF_NULLABLE fec_controller_rplr_based) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_controller();
  if (fec_controller_rplr_based) {
    ::google::protobuf::Arena* submessage_arena = fec_controller_rplr_based->GetArena();
    if (message_arena != submessage_arena) {
      fec_controller_rplr_based = ::google::protobuf::internal::GetOwnedMessage(message_arena, fec_controller_rplr_based, submessage_arena);
    }
    set_has_fec_controller_rplr_based();
    _impl_.controller_.fec_controller_rplr_based_ = fec_controller_rplr_based;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.fec_controller_rplr_based)
}
void Controller::set_allocated_frame_length_controller_v2(::webrtc::audio_network_adaptor::config::FrameLengthControllerV2* PROTOBUF_NULLABLE frame_length_controller_v2) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_controller();
  if (frame_length_controller_v2) {
    ::google::protobuf::Arena* submessage_arena = frame_length_controller_v2->GetArena();
    if (message_arena != submessage_arena) {
      frame_length_controller_v2 = ::google::protobuf::internal::GetOwnedMessage(message_arena, frame_length_controller_v2, submessage_arena);
    }
    set_has_frame_length_controller_v2();
    _impl_.controller_.frame_length_controller_v2_ = frame_length_controller_v2;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.frame_length_controller_v2)
}
Controller::Controller(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, Controller_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.Controller)
}
PROTOBUF_NDEBUG_INLINE Controller::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::webrtc::audio_network_adaptor::config::Controller& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        controller_{},
        _oneof_case_{from._oneof_case_[0]} {}

Controller::Controller(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const Controller& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, Controller_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  Controller* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.scoring_point_ = (CheckHasBit(cached_has_bits, 0x00000001U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.scoring_point_)
                : nullptr;
  switch (controller_case()) {
    case CONTROLLER_NOT_SET:
      break;
      case kFecController:
        _impl_.controller_.fec_controller_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.fec_controller_);
        break;
      case kFrameLengthController:
        _impl_.controller_.frame_length_controller_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.frame_length_controller_);
        break;
      case kChannelController:
        _impl_.controller_.channel_controller_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.channel_controller_);
        break;
      case kDtxController:
        _impl_.controller_.dtx_controller_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.dtx_controller_);
        break;
      case kBitrateController:
        _impl_.controller_.bitrate_controller_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.bitrate_controller_);
        break;
      case kFecControllerRplrBased:
        _impl_.controller_.fec_controller_rplr_based_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.fec_controller_rplr_based_);
        break;
      case kFrameLengthControllerV2:
        _impl_.controller_.frame_length_controller_v2_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.frame_length_controller_v2_);
        break;
  }

  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.Controller)
}
PROTOBUF_NDEBUG_INLINE Controller::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        controller_{},
        _oneof_case_{} {}

inline void Controller::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.scoring_point_ = {};
}
Controller::~Controller() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.Controller)
  SharedDtor(*this);
}
inline void Controller::SharedDtor(MessageLite& self) {
  Controller& this_ = static_cast<Controller&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.scoring_point_;
  if (this_.has_controller()) {
    this_.clear_controller();
  }
  this_._impl_.~Impl_();
}

void Controller::clear_controller() {
// @@protoc_insertion_point(one_of_clear_start:webrtc.audio_network_adaptor.config.Controller)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  switch (controller_case()) {
    case kFecController: {
      if (GetArena() == nullptr) {
        delete _impl_.controller_.fec_controller_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.controller_.fec_controller_ != nullptr) {
          _impl_.controller_.fec_controller_->Clear();
        }
      }
      break;
    }
    case kFrameLengthController: {
      if (GetArena() == nullptr) {
        delete _impl_.controller_.frame_length_controller_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.controller_.frame_length_controller_ != nullptr) {
          _impl_.controller_.frame_length_controller_->Clear();
        }
      }
      break;
    }
    case kChannelController: {
      if (GetArena() == nullptr) {
        delete _impl_.controller_.channel_controller_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.controller_.channel_controller_ != nullptr) {
          _impl_.controller_.channel_controller_->Clear();
        }
      }
      break;
    }
    case kDtxController: {
      if (GetArena() == nullptr) {
        delete _impl_.controller_.dtx_controller_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.controller_.dtx_controller_ != nullptr) {
          _impl_.controller_.dtx_controller_->Clear();
        }
      }
      break;
    }
    case kBitrateController: {
      if (GetArena() == nullptr) {
        delete _impl_.controller_.bitrate_controller_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.controller_.bitrate_controller_ != nullptr) {
          _impl_.controller_.bitrate_controller_->Clear();
        }
      }
      break;
    }
    case kFecControllerRplrBased: {
      if (GetArena() == nullptr) {
        delete _impl_.controller_.fec_controller_rplr_based_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.controller_.fec_controller_rplr_based_ != nullptr) {
          _impl_.controller_.fec_controller_rplr_based_->Clear();
        }
      }
      break;
    }
    case kFrameLengthControllerV2: {
      if (GetArena() == nullptr) {
        delete _impl_.controller_.frame_length_controller_v2_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.controller_.frame_length_controller_v2_ != nullptr) {
          _impl_.controller_.frame_length_controller_v2_->Clear();
        }
      }
      break;
    }
    case CONTROLLER_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = CONTROLLER_NOT_SET;
}


#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite Controller_class_data_ =
    Controller::InternalGenerateClassData_(Controller_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
Controller::GetClassData() const {
  return Controller_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
Controller::GetClassData() const {
  return Controller_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const Controller::ParseTableT_
    Controller::_table_ =
        Controller::InternalGenerateParseTable_(Controller_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void Controller::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.Controller)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    ABSL_DCHECK(_impl_.scoring_point_ != nullptr);
    _impl_.scoring_point_->Clear();
  }
  clear_controller();
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL Controller::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const Controller& this_ = static_cast<const Controller&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL Controller::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const Controller& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.Controller)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .webrtc.audio_network_adaptor.config.Controller.ScoringPoint scoring_point = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        1, *this_._impl_.scoring_point_, this_._impl_.scoring_point_->GetCachedSize(), target,
        stream);
  }

  switch (this_.controller_case()) {
    case kFecController: {
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          21, *this_._impl_.controller_.fec_controller_, this_._impl_.controller_.fec_controller_->GetCachedSize(), target,
          stream);
      break;
    }
    case kFrameLengthController: {
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          22, *this_._impl_.controller_.frame_length_controller_, this_._impl_.controller_.frame_length_controller_->GetCachedSize(), target,
          stream);
      break;
    }
    case kChannelController: {
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          23, *this_._impl_.controller_.channel_controller_, this_._impl_.controller_.channel_controller_->GetCachedSize(), target,
          stream);
      break;
    }
    case kDtxController: {
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          24, *this_._impl_.controller_.dtx_controller_, this_._impl_.controller_.dtx_controller_->GetCachedSize(), target,
          stream);
      break;
    }
    case kBitrateController: {
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          25, *this_._impl_.controller_.bitrate_controller_, this_._impl_.controller_.bitrate_controller_->GetCachedSize(), target,
          stream);
      break;
    }
    case kFecControllerRplrBased: {
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          26, *this_._impl_.controller_.fec_controller_rplr_based_, this_._impl_.controller_.fec_controller_rplr_based_->GetCachedSize(), target,
          stream);
      break;
    }
    case kFrameLengthControllerV2: {
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          27, *this_._impl_.controller_.frame_length_controller_v2_, this_._impl_.controller_.frame_length_controller_v2_->GetCachedSize(), target,
          stream);
      break;
    }
    default:
      break;
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.Controller)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t Controller::ByteSizeLong(const MessageLite& base) {
  const Controller& this_ = static_cast<const Controller&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t Controller::ByteSizeLong() const {
  const Controller& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.Controller)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

   {
    // optional .webrtc.audio_network_adaptor.config.Controller.ScoringPoint scoring_point = 1;
    cached_has_bits = this_._impl_._has_bits_[0];
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.scoring_point_);
    }
  }
  switch (this_.controller_case()) {
    // .webrtc.audio_network_adaptor.config.FecController fec_controller = 21;
    case kFecController: {
      total_size += 2 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.controller_.fec_controller_);
      break;
    }
    // .webrtc.audio_network_adaptor.config.FrameLengthController frame_length_controller = 22;
    case kFrameLengthController: {
      total_size += 2 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.controller_.frame_length_controller_);
      break;
    }
    // .webrtc.audio_network_adaptor.config.ChannelController channel_controller = 23;
    case kChannelController: {
      total_size += 2 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.controller_.channel_controller_);
      break;
    }
    // .webrtc.audio_network_adaptor.config.DtxController dtx_controller = 24;
    case kDtxController: {
      total_size += 2 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.controller_.dtx_controller_);
      break;
    }
    // .webrtc.audio_network_adaptor.config.BitrateController bitrate_controller = 25;
    case kBitrateController: {
      total_size += 2 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.controller_.bitrate_controller_);
      break;
    }
    // .webrtc.audio_network_adaptor.config.FecControllerRplrBased fec_controller_rplr_based = 26;
    case kFecControllerRplrBased: {
      total_size += 2 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.controller_.fec_controller_rplr_based_);
      break;
    }
    // .webrtc.audio_network_adaptor.config.FrameLengthControllerV2 frame_length_controller_v2 = 27;
    case kFrameLengthControllerV2: {
      total_size += 2 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.controller_.frame_length_controller_v2_);
      break;
    }
    case CONTROLLER_NOT_SET: {
      break;
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void Controller::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<Controller*>(&to_msg);
  auto& from = static_cast<const Controller&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.Controller)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    ABSL_DCHECK(from._impl_.scoring_point_ != nullptr);
    if (_this->_impl_.scoring_point_ == nullptr) {
      _this->_impl_.scoring_point_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.scoring_point_);
    } else {
      _this->_impl_.scoring_point_->MergeFrom(*from._impl_.scoring_point_);
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  if (const uint32_t oneof_from_case =
          from._impl_._oneof_case_[0]) {
    const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0];
    const bool oneof_needs_init = oneof_to_case != oneof_from_case;
    if (oneof_needs_init) {
      if (oneof_to_case != 0) {
        _this->clear_controller();
      }
      _this->_impl_._oneof_case_[0] = oneof_from_case;
    }

    switch (oneof_from_case) {
      case kFecController: {
        if (oneof_needs_init) {
          _this->_impl_.controller_.fec_controller_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.fec_controller_);
        } else {
          _this->_impl_.controller_.fec_controller_->CheckTypeAndMergeFrom(*from._impl_.controller_.fec_controller_);
        }
        break;
      }
      case kFrameLengthController: {
        if (oneof_needs_init) {
          _this->_impl_.controller_.frame_length_controller_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.frame_length_controller_);
        } else {
          _this->_impl_.controller_.frame_length_controller_->CheckTypeAndMergeFrom(*from._impl_.controller_.frame_length_controller_);
        }
        break;
      }
      case kChannelController: {
        if (oneof_needs_init) {
          _this->_impl_.controller_.channel_controller_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.channel_controller_);
        } else {
          _this->_impl_.controller_.channel_controller_->CheckTypeAndMergeFrom(*from._impl_.controller_.channel_controller_);
        }
        break;
      }
      case kDtxController: {
        if (oneof_needs_init) {
          _this->_impl_.controller_.dtx_controller_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.dtx_controller_);
        } else {
          _this->_impl_.controller_.dtx_controller_->CheckTypeAndMergeFrom(*from._impl_.controller_.dtx_controller_);
        }
        break;
      }
      case kBitrateController: {
        if (oneof_needs_init) {
          _this->_impl_.controller_.bitrate_controller_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.bitrate_controller_);
        } else {
          _this->_impl_.controller_.bitrate_controller_->CheckTypeAndMergeFrom(*from._impl_.controller_.bitrate_controller_);
        }
        break;
      }
      case kFecControllerRplrBased: {
        if (oneof_needs_init) {
          _this->_impl_.controller_.fec_controller_rplr_based_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.fec_controller_rplr_based_);
        } else {
          _this->_impl_.controller_.fec_controller_rplr_based_->CheckTypeAndMergeFrom(*from._impl_.controller_.fec_controller_rplr_based_);
        }
        break;
      }
      case kFrameLengthControllerV2: {
        if (oneof_needs_init) {
          _this->_impl_.controller_.frame_length_controller_v2_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.controller_.frame_length_controller_v2_);
        } else {
          _this->_impl_.controller_.frame_length_controller_v2_->CheckTypeAndMergeFrom(*from._impl_.controller_.frame_length_controller_v2_);
        }
        break;
      }
      case CONTROLLER_NOT_SET:
        break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void Controller::CopyFrom(const Controller& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.Controller)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void Controller::InternalSwap(Controller* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.scoring_point_, other->_impl_.scoring_point_);
  swap(_impl_.controller_, other->_impl_.controller_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

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

ControllerManager::ControllerManager(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, ControllerManager_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:webrtc.audio_network_adaptor.config.ControllerManager)
}
PROTOBUF_NDEBUG_INLINE ControllerManager::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::webrtc::audio_network_adaptor::config::ControllerManager& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        controllers_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::webrtc::audio_network_adaptor::config::ControllerManager,
              PROTOBUF_FIELD_OFFSET(::webrtc::audio_network_adaptor::config::ControllerManager, _impl_.controllers_)>()
          , from.controllers_
        }
     {}

ControllerManager::ControllerManager(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const ControllerManager& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, ControllerManager_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  ControllerManager* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, min_reordering_time_ms_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, min_reordering_time_ms_),
           offsetof(Impl_, min_reordering_squared_distance_) -
               offsetof(Impl_, min_reordering_time_ms_) +
               sizeof(Impl_::min_reordering_squared_distance_));

  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.ControllerManager)
}
PROTOBUF_NDEBUG_INLINE ControllerManager::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        controllers_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::webrtc::audio_network_adaptor::config::ControllerManager,
            PROTOBUF_FIELD_OFFSET(::webrtc::audio_network_adaptor::config::ControllerManager, _impl_.controllers_)>()
         }
     {}

inline void ControllerManager::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, min_reordering_time_ms_),
           0,
           offsetof(Impl_, min_reordering_squared_distance_) -
               offsetof(Impl_, min_reordering_time_ms_) +
               sizeof(Impl_::min_reordering_squared_distance_));
}
ControllerManager::~ControllerManager() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.ControllerManager)
  SharedDtor(*this);
}
inline void ControllerManager::SharedDtor(MessageLite& self) {
  ControllerManager& this_ = static_cast<ControllerManager&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite ControllerManager_class_data_ =
    ControllerManager::InternalGenerateClassData_(ControllerManager_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
ControllerManager::GetClassData() const {
  return ControllerManager_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
ControllerManager::GetClassData() const {
  return ControllerManager_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ControllerManager::ParseTableT_
    ControllerManager::_table_ =
        ControllerManager::InternalGenerateParseTable_(ControllerManager_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void ControllerManager::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.ControllerManager)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    _impl_.controllers_.Clear();
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00000006U)) {
    ::memset(&_impl_.min_reordering_time_ms_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.min_reordering_squared_distance_) -
        reinterpret_cast<char*>(&_impl_.min_reordering_time_ms_)) + sizeof(_impl_.min_reordering_squared_distance_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL ControllerManager::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const ControllerManager& this_ = static_cast<const ControllerManager&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL ControllerManager::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const ControllerManager& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:webrtc.audio_network_adaptor.config.ControllerManager)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // repeated .webrtc.audio_network_adaptor.config.Controller controllers = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_controllers_size());
         i < n; i++) {
      const auto& repfield = this_._internal_controllers().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              1, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // optional int32 min_reordering_time_ms = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>(
            stream, this_._internal_min_reordering_time_ms(), target);
  }

  // optional float min_reordering_squared_distance = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        3, this_._internal_min_reordering_squared_distance(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:webrtc.audio_network_adaptor.config.ControllerManager)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t ControllerManager::ByteSizeLong(const MessageLite& base) {
  const ControllerManager& this_ = static_cast<const ControllerManager&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t ControllerManager::ByteSizeLong() const {
  const ControllerManager& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.ControllerManager)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += static_cast<bool>(0x00000004U & cached_has_bits) * 5;
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // repeated .webrtc.audio_network_adaptor.config.Controller controllers = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_controllers_size();
      for (const auto& msg : this_._internal_controllers()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional int32 min_reordering_time_ms = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_min_reordering_time_ms());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void ControllerManager::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<ControllerManager*>(&to_msg);
  auto& from = static_cast<const ControllerManager&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.ControllerManager)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_controllers()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_controllers());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.min_reordering_time_ms_ = from._impl_.min_reordering_time_ms_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.min_reordering_squared_distance_ = from._impl_.min_reordering_squared_distance_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void ControllerManager::CopyFrom(const ControllerManager& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.ControllerManager)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void ControllerManager::InternalSwap(ControllerManager* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.controllers_.InternalSwap(&other->_impl_.controllers_);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ControllerManager, _impl_.min_reordering_squared_distance_)
      + sizeof(ControllerManager::_impl_.min_reordering_squared_distance_)
      - PROTOBUF_FIELD_OFFSET(ControllerManager, _impl_.min_reordering_time_ms_)>(
          reinterpret_cast<char*>(&_impl_.min_reordering_time_ms_),
          reinterpret_cast<char*>(&other->_impl_.min_reordering_time_ms_));
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace config
}  // namespace audio_network_adaptor
}  // namespace webrtc
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"