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

#include "components/optimization_guide/proto/text_safety_model_metadata.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 optimization_guide {
namespace proto {
class SafetyCategoryThreshold::_Internal {
 public:
  using HasBits = decltype(::std::declval<SafetyCategoryThreshold>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(SafetyCategoryThreshold, _impl_._has_bits_);
};

constexpr SafetyCategoryThreshold::ParseTableT_ SafetyCategoryThreshold::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(SafetyCategoryThreshold, _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
      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<::optimization_guide::proto::SafetyCategoryThreshold>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // optional string category_label = 1;
      {::_pbi::TcParser::FastBS1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(SafetyCategoryThreshold, _impl_.category_label_)}},
      // optional uint32 output_index = 2;
      {::_pbi::TcParser::FastV32S1,
       {16, 1, 0,
        PROTOBUF_FIELD_OFFSET(SafetyCategoryThreshold, _impl_.output_index_)}},
      // optional float threshold = 3;
      {::_pbi::TcParser::FastF32S1,
       {29, 2, 0,
        PROTOBUF_FIELD_OFFSET(SafetyCategoryThreshold, _impl_.threshold_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional string category_label = 1;
      {PROTOBUF_FIELD_OFFSET(SafetyCategoryThreshold, _impl_.category_label_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
      // optional uint32 output_index = 2;
      {PROTOBUF_FIELD_OFFSET(SafetyCategoryThreshold, _impl_.output_index_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // optional float threshold = 3;
      {PROTOBUF_FIELD_OFFSET(SafetyCategoryThreshold, _impl_.threshold_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr SafetyCategoryThreshold::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        category_label_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        output_index_{0u},
        threshold_{0} {}

template <typename>
constexpr SafetyCategoryThreshold::SafetyCategoryThreshold(::_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 SafetyCategoryThreshold::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) SafetyCategoryThreshold(arena);
}
constexpr auto SafetyCategoryThreshold::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SafetyCategoryThreshold), alignof(SafetyCategoryThreshold));
}
constexpr auto SafetyCategoryThreshold::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
          &SafetyCategoryThreshold::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<SafetyCategoryThreshold>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &SafetyCategoryThreshold::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<SafetyCategoryThreshold>(), &SafetyCategoryThreshold::ByteSizeLong,
              &SafetyCategoryThreshold::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(SafetyCategoryThreshold, _impl_._cached_size_),
          true,
      },
      "optimization_guide.proto.SafetyCategoryThreshold",
  };
}
struct SafetyCategoryThresholdGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr SafetyCategoryThresholdGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 SafetyCategoryThreshold_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(SafetyCategoryThreshold::InternalGenerateClassData_(
            _default, &SafetyCategoryThreshold_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<SafetyCategoryThreshold>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~SafetyCategoryThresholdGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) SafetyCategoryThreshold _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<SafetyCategoryThreshold>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(SafetyCategoryThresholdGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

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

constexpr RegexFilter::ParseTableT_ RegexFilter::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(RegexFilter, _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
      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<::optimization_guide::proto::RegexFilter>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional string regex = 2;
      {::_pbi::TcParser::FastBS1,
       {18, 0, 0,
        PROTOBUF_FIELD_OFFSET(RegexFilter, _impl_.regex_)}},
      // optional .optimization_guide.proto.RegexFilterType type = 1;
      {::_pbi::TcParser::FastEr0S1,
       {8, 1, 2,
        PROTOBUF_FIELD_OFFSET(RegexFilter, _impl_.type_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional .optimization_guide.proto.RegexFilterType type = 1;
      {PROTOBUF_FIELD_OFFSET(RegexFilter, _impl_.type_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
      // optional string regex = 2;
      {PROTOBUF_FIELD_OFFSET(RegexFilter, _impl_.regex_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
    }},
    {{
        {0, 2},
    }},
    {{
    }},
  };
}


inline constexpr RegexFilter::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        regex_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        type_{static_cast< ::optimization_guide::proto::RegexFilterType >(0)} {}

template <typename>
constexpr RegexFilter::RegexFilter(::_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 RegexFilter::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) RegexFilter(arena);
}
constexpr auto RegexFilter::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RegexFilter), alignof(RegexFilter));
}
constexpr auto RegexFilter::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
          &RegexFilter::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<RegexFilter>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &RegexFilter::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<RegexFilter>(), &RegexFilter::ByteSizeLong,
              &RegexFilter::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(RegexFilter, _impl_._cached_size_),
          true,
      },
      "optimization_guide.proto.RegexFilter",
  };
}
struct RegexFilterGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr RegexFilterGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 RegexFilter_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(RegexFilter::InternalGenerateClassData_(
            _default, &RegexFilter_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<RegexFilter>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~RegexFilterGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) RegexFilter _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<RegexFilter>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(RegexFilterGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

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

constexpr PartialOutputChecks::ParseTableT_ PartialOutputChecks::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(PartialOutputChecks, _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<::optimization_guide::proto::PartialOutputChecks>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional uint32 token_interval = 2;
      {::_pbi::TcParser::FastV32S1,
       {16, 1, 0,
        PROTOBUF_FIELD_OFFSET(PartialOutputChecks, _impl_.token_interval_)}},
      // optional uint32 minimum_tokens = 1;
      {::_pbi::TcParser::FastV32S1,
       {8, 0, 0,
        PROTOBUF_FIELD_OFFSET(PartialOutputChecks, _impl_.minimum_tokens_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional uint32 minimum_tokens = 1;
      {PROTOBUF_FIELD_OFFSET(PartialOutputChecks, _impl_.minimum_tokens_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // optional uint32 token_interval = 2;
      {PROTOBUF_FIELD_OFFSET(PartialOutputChecks, _impl_.token_interval_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr PartialOutputChecks::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        minimum_tokens_{0u},
        token_interval_{0u} {}

template <typename>
constexpr PartialOutputChecks::PartialOutputChecks(::_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 PartialOutputChecks::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) PartialOutputChecks(arena);
}
constexpr auto PartialOutputChecks::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(PartialOutputChecks), alignof(PartialOutputChecks));
}
constexpr auto PartialOutputChecks::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
          &PartialOutputChecks::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<PartialOutputChecks>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &PartialOutputChecks::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<PartialOutputChecks>(), &PartialOutputChecks::ByteSizeLong,
              &PartialOutputChecks::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(PartialOutputChecks, _impl_._cached_size_),
          true,
      },
      "optimization_guide.proto.PartialOutputChecks",
  };
}
struct PartialOutputChecksGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr PartialOutputChecksGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 PartialOutputChecks_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(PartialOutputChecks::InternalGenerateClassData_(
            _default, &PartialOutputChecks_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<PartialOutputChecks>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~PartialOutputChecksGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) PartialOutputChecks _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<PartialOutputChecks>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(PartialOutputChecksGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

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

constexpr LanguageCheck::ParseTableT_ LanguageCheck::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(LanguageCheck, _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<::optimization_guide::proto::LanguageCheck>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional double partial_threshold = 2;
      {::_pbi::TcParser::FastF64S1,
       {17, 1, 0,
        PROTOBUF_FIELD_OFFSET(LanguageCheck, _impl_.partial_threshold_)}},
      // optional double confidence_threshold = 1;
      {::_pbi::TcParser::FastF64S1,
       {9, 0, 0,
        PROTOBUF_FIELD_OFFSET(LanguageCheck, _impl_.confidence_threshold_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional double confidence_threshold = 1;
      {PROTOBUF_FIELD_OFFSET(LanguageCheck, _impl_.confidence_threshold_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
      // optional double partial_threshold = 2;
      {PROTOBUF_FIELD_OFFSET(LanguageCheck, _impl_.partial_threshold_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr LanguageCheck::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        confidence_threshold_{0},
        partial_threshold_{0} {}

template <typename>
constexpr LanguageCheck::LanguageCheck(::_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 LanguageCheck::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) LanguageCheck(arena);
}
constexpr auto LanguageCheck::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(LanguageCheck), alignof(LanguageCheck));
}
constexpr auto LanguageCheck::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
          &LanguageCheck::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<LanguageCheck>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &LanguageCheck::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<LanguageCheck>(), &LanguageCheck::ByteSizeLong,
              &LanguageCheck::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(LanguageCheck, _impl_._cached_size_),
          true,
      },
      "optimization_guide.proto.LanguageCheck",
  };
}
struct LanguageCheckGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr LanguageCheckGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 LanguageCheck_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(LanguageCheck::InternalGenerateClassData_(
            _default, &LanguageCheck_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<LanguageCheck>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~LanguageCheckGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) LanguageCheck _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<LanguageCheck>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(LanguageCheckGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

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

constexpr RequestSafetyCheck::ParseTableT_ RequestSafetyCheck::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_._has_bits_),
      0, // no _extensions_
      6, 56,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967232,  // skipmap
      offsetof(ParseTableT_, field_entries),
      6,  // num_field_entries
      4,  // 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<::optimization_guide::proto::RequestSafetyCheck>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // repeated .optimization_guide.proto.SubstitutedString input_template = 1;
      {::_pbi::TcParser::FastMtR1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.input_template_)}},
      // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
      {::_pbi::TcParser::FastMtR1,
       {18, 1, 1,
        PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.safety_category_thresholds_)}},
      // optional bool check_language_only = 3;
      {::_pbi::TcParser::FastV8S1,
       {24, 4, 0,
        PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.check_language_only_)}},
      // optional bool ignore_language_result = 4;
      {::_pbi::TcParser::FastV8S1,
       {32, 5, 0,
        PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.ignore_language_result_)}},
      // optional .optimization_guide.proto.LanguageCheck language_check = 5;
      {::_pbi::TcParser::FastMtS1,
       {42, 2, 2,
        PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.language_check_)}},
      // optional .optimization_guide.proto.RegexFilter regex_filter = 6;
      {::_pbi::TcParser::FastMtS1,
       {50, 3, 3,
        PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.regex_filter_)}},
      {::_pbi::TcParser::MiniParse, {}},
    }}, {{
      65535, 65535
    }}, {{
      // repeated .optimization_guide.proto.SubstitutedString input_template = 1;
      {PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.input_template_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
      {PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.safety_category_thresholds_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional bool check_language_only = 3;
      {PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.check_language_only_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)},
      // optional bool ignore_language_result = 4;
      {PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.ignore_language_result_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)},
      // optional .optimization_guide.proto.LanguageCheck language_check = 5;
      {PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.language_check_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .optimization_guide.proto.RegexFilter regex_filter = 6;
      {PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.regex_filter_), _Internal::kHasBitsOffset + 3, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::SubstitutedString>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::SubstitutedString_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::SafetyCategoryThreshold>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::SafetyCategoryThreshold_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::LanguageCheck>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::LanguageCheck_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::RegexFilter>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::RegexFilter_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr RequestSafetyCheck::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        input_template_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::RequestSafetyCheck,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::RequestSafetyCheck, _impl_.input_template_)>()
         }
        ,
        safety_category_thresholds_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::RequestSafetyCheck,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::RequestSafetyCheck, _impl_.safety_category_thresholds_)>()
         }
        ,
        language_check_{nullptr},
        regex_filter_{nullptr},
        check_language_only_{false},
        ignore_language_result_{false} {}

template <typename>
constexpr RequestSafetyCheck::RequestSafetyCheck(::_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 RequestSafetyCheck::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) RequestSafetyCheck(arena);
}
constexpr auto RequestSafetyCheck::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RequestSafetyCheck), alignof(RequestSafetyCheck));
}
constexpr auto RequestSafetyCheck::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
          &RequestSafetyCheck::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<RequestSafetyCheck>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &RequestSafetyCheck::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<RequestSafetyCheck>(), &RequestSafetyCheck::ByteSizeLong,
              &RequestSafetyCheck::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_._cached_size_),
          true,
      },
      "optimization_guide.proto.RequestSafetyCheck",
  };
}
struct RequestSafetyCheckGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr RequestSafetyCheckGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 RequestSafetyCheck_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(RequestSafetyCheck::InternalGenerateClassData_(
            _default, &RequestSafetyCheck_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<RequestSafetyCheck>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~RequestSafetyCheckGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) RequestSafetyCheck _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<RequestSafetyCheck>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(RequestSafetyCheckGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

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

constexpr RawOutputCheck::ParseTableT_ RawOutputCheck::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(RawOutputCheck, _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
      3,  // 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<::optimization_guide::proto::RawOutputCheck>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // repeated .optimization_guide.proto.SubstitutedString input_template = 1;
      {::_pbi::TcParser::FastMtR1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(RawOutputCheck, _impl_.input_template_)}},
      // optional .optimization_guide.proto.LanguageCheck language_check = 2;
      {::_pbi::TcParser::FastMtS1,
       {18, 1, 1,
        PROTOBUF_FIELD_OFFSET(RawOutputCheck, _impl_.language_check_)}},
      // optional .optimization_guide.proto.RegexFilter regex_filter = 3;
      {::_pbi::TcParser::FastMtS1,
       {26, 2, 2,
        PROTOBUF_FIELD_OFFSET(RawOutputCheck, _impl_.regex_filter_)}},
    }}, {{
      65535, 65535
    }}, {{
      // repeated .optimization_guide.proto.SubstitutedString input_template = 1;
      {PROTOBUF_FIELD_OFFSET(RawOutputCheck, _impl_.input_template_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .optimization_guide.proto.LanguageCheck language_check = 2;
      {PROTOBUF_FIELD_OFFSET(RawOutputCheck, _impl_.language_check_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .optimization_guide.proto.RegexFilter regex_filter = 3;
      {PROTOBUF_FIELD_OFFSET(RawOutputCheck, _impl_.regex_filter_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::SubstitutedString>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::SubstitutedString_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::LanguageCheck>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::LanguageCheck_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::RegexFilter>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::RegexFilter_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr RawOutputCheck::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        input_template_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::RawOutputCheck,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::RawOutputCheck, _impl_.input_template_)>()
         }
        ,
        language_check_{nullptr},
        regex_filter_{nullptr} {}

template <typename>
constexpr RawOutputCheck::RawOutputCheck(::_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 RawOutputCheck::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) RawOutputCheck(arena);
}
constexpr auto RawOutputCheck::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RawOutputCheck), alignof(RawOutputCheck));
}
constexpr auto RawOutputCheck::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
          &RawOutputCheck::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<RawOutputCheck>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &RawOutputCheck::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<RawOutputCheck>(), &RawOutputCheck::ByteSizeLong,
              &RawOutputCheck::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(RawOutputCheck, _impl_._cached_size_),
          true,
      },
      "optimization_guide.proto.RawOutputCheck",
  };
}
struct RawOutputCheckGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr RawOutputCheckGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 RawOutputCheck_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(RawOutputCheck::InternalGenerateClassData_(
            _default, &RawOutputCheck_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<RawOutputCheck>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~RawOutputCheckGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) RawOutputCheck _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<RawOutputCheck>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(RawOutputCheckGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

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

constexpr CheckInput::ParseTableT_ CheckInput::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(CheckInput, _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<::optimization_guide::proto::CheckInput>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // repeated .optimization_guide.proto.SubstitutedString templates = 2;
      {::_pbi::TcParser::FastMtR1,
       {18, 0, 0,
        PROTOBUF_FIELD_OFFSET(CheckInput, _impl_.templates_)}},
      // optional .optimization_guide.proto.CheckInputType input_type = 1;
      {::_pbi::TcParser::FastEr0S1,
       {8, 1, 2,
        PROTOBUF_FIELD_OFFSET(CheckInput, _impl_.input_type_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional .optimization_guide.proto.CheckInputType input_type = 1;
      {PROTOBUF_FIELD_OFFSET(CheckInput, _impl_.input_type_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
      // repeated .optimization_guide.proto.SubstitutedString templates = 2;
      {PROTOBUF_FIELD_OFFSET(CheckInput, _impl_.templates_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::SubstitutedString>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::SubstitutedString_globals_},
        #endif
        {0, 2},
    }},
    {{
    }},
  };
}


inline constexpr CheckInput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        templates_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::CheckInput,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::CheckInput, _impl_.templates_)>()
         }
        ,
        input_type_{static_cast< ::optimization_guide::proto::CheckInputType >(0)} {}

template <typename>
constexpr CheckInput::CheckInput(::_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 CheckInput::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) CheckInput(arena);
}
constexpr auto CheckInput::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(CheckInput), alignof(CheckInput));
}
constexpr auto CheckInput::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
          &CheckInput::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<CheckInput>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &CheckInput::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<CheckInput>(), &CheckInput::ByteSizeLong,
              &CheckInput::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(CheckInput, _impl_._cached_size_),
          true,
      },
      "optimization_guide.proto.CheckInput",
  };
}
struct CheckInputGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr CheckInputGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 CheckInput_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(CheckInput::InternalGenerateClassData_(
            _default, &CheckInput_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<CheckInput>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~CheckInputGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) CheckInput _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<CheckInput>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(CheckInputGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

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

constexpr ResponseSafetyCheck::ParseTableT_ ResponseSafetyCheck::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_._has_bits_),
      0, // no _extensions_
      6, 56,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967248,  // skipmap
      offsetof(ParseTableT_, field_entries),
      5,  // num_field_entries
      4,  // 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<::optimization_guide::proto::ResponseSafetyCheck>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // repeated .optimization_guide.proto.CheckInput inputs = 1;
      {::_pbi::TcParser::FastMtR1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.inputs_)}},
      // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
      {::_pbi::TcParser::FastMtR1,
       {18, 1, 1,
        PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.safety_category_thresholds_)}},
      // optional bool ignore_language_result = 3;
      {::_pbi::TcParser::FastV8S1,
       {24, 4, 0,
        PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.ignore_language_result_)}},
      // optional .optimization_guide.proto.LanguageCheck language_check = 4;
      {::_pbi::TcParser::FastMtS1,
       {34, 2, 2,
        PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.language_check_)}},
      {::_pbi::TcParser::MiniParse, {}},
      // optional .optimization_guide.proto.RegexFilter regex_filter = 6;
      {::_pbi::TcParser::FastMtS1,
       {50, 3, 3,
        PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.regex_filter_)}},
      {::_pbi::TcParser::MiniParse, {}},
    }}, {{
      65535, 65535
    }}, {{
      // repeated .optimization_guide.proto.CheckInput inputs = 1;
      {PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.inputs_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
      {PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.safety_category_thresholds_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional bool ignore_language_result = 3;
      {PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.ignore_language_result_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)},
      // optional .optimization_guide.proto.LanguageCheck language_check = 4;
      {PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.language_check_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .optimization_guide.proto.RegexFilter regex_filter = 6;
      {PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.regex_filter_), _Internal::kHasBitsOffset + 3, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::CheckInput>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::CheckInput_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::SafetyCategoryThreshold>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::SafetyCategoryThreshold_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::LanguageCheck>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::LanguageCheck_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::RegexFilter>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::RegexFilter_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr ResponseSafetyCheck::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        inputs_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::ResponseSafetyCheck,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::ResponseSafetyCheck, _impl_.inputs_)>()
         }
        ,
        safety_category_thresholds_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::ResponseSafetyCheck,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::ResponseSafetyCheck, _impl_.safety_category_thresholds_)>()
         }
        ,
        language_check_{nullptr},
        regex_filter_{nullptr},
        ignore_language_result_{false} {}

template <typename>
constexpr ResponseSafetyCheck::ResponseSafetyCheck(::_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 ResponseSafetyCheck::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) ResponseSafetyCheck(arena);
}
constexpr auto ResponseSafetyCheck::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ResponseSafetyCheck), alignof(ResponseSafetyCheck));
}
constexpr auto ResponseSafetyCheck::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
          &ResponseSafetyCheck::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<ResponseSafetyCheck>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &ResponseSafetyCheck::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<ResponseSafetyCheck>(), &ResponseSafetyCheck::ByteSizeLong,
              &ResponseSafetyCheck::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_._cached_size_),
          true,
      },
      "optimization_guide.proto.ResponseSafetyCheck",
  };
}
struct ResponseSafetyCheckGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr ResponseSafetyCheckGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 ResponseSafetyCheck_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(ResponseSafetyCheck::InternalGenerateClassData_(
            _default, &ResponseSafetyCheck_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<ResponseSafetyCheck>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~ResponseSafetyCheckGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) ResponseSafetyCheck _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<ResponseSafetyCheck>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(ResponseSafetyCheckGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

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

constexpr FeatureTextSafetyConfiguration::ParseTableT_ FeatureTextSafetyConfiguration::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_._has_bits_),
      0, // no _extensions_
      8, 56,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967040,  // skipmap
      offsetof(ParseTableT_, field_entries),
      8,  // num_field_entries
      6,  // 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<::optimization_guide::proto::FeatureTextSafetyConfiguration>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional .optimization_guide.proto.PartialOutputChecks partial_output_checks = 8;
      {::_pbi::TcParser::FastMtS1,
       {66, 5, 4,
        PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.partial_output_checks_)}},
      // optional .optimization_guide.proto.ModelExecutionFeature feature = 1;
      {::_pbi::TcParser::FastEvS1,
       {8, 6, 5,
        PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.feature_)}},
      // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
      {::_pbi::TcParser::FastMtR1,
       {18, 0, 0,
        PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.safety_category_thresholds_)}},
      // repeated string allowed_languages = 3;
      {::_pbi::TcParser::FastBR1,
       {26, 1, 0,
        PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.allowed_languages_)}},
      // repeated .optimization_guide.proto.RequestSafetyCheck request_check = 4;
      {::_pbi::TcParser::FastMtR1,
       {34, 2, 1,
        PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.request_check_)}},
      // optional .optimization_guide.proto.RawOutputCheck raw_output_check = 5;
      {::_pbi::TcParser::FastMtS1,
       {42, 4, 2,
        PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.raw_output_check_)}},
      // repeated .optimization_guide.proto.ResponseSafetyCheck response_check = 6;
      {::_pbi::TcParser::FastMtR1,
       {50, 3, 3,
        PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.response_check_)}},
      // optional bool only_cancel_unsafe_response_on_complete = 7;
      {::_pbi::TcParser::FastV8S1,
       {56, 7, 0,
        PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.only_cancel_unsafe_response_on_complete_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional .optimization_guide.proto.ModelExecutionFeature feature = 1;
      {PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.feature_), _Internal::kHasBitsOffset + 6, 5, (0 | ::_fl::kFcOptional | ::_fl::kEnum)},
      // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
      {PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.safety_category_thresholds_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // repeated string allowed_languages = 3;
      {PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.allowed_languages_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)},
      // repeated .optimization_guide.proto.RequestSafetyCheck request_check = 4;
      {PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.request_check_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .optimization_guide.proto.RawOutputCheck raw_output_check = 5;
      {PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.raw_output_check_), _Internal::kHasBitsOffset + 4, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // repeated .optimization_guide.proto.ResponseSafetyCheck response_check = 6;
      {PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.response_check_), _Internal::kHasBitsOffset + 3, 3, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional bool only_cancel_unsafe_response_on_complete = 7;
      {PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.only_cancel_unsafe_response_on_complete_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)},
      // optional .optimization_guide.proto.PartialOutputChecks partial_output_checks = 8;
      {PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.partial_output_checks_), _Internal::kHasBitsOffset + 5, 4, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::SafetyCategoryThreshold>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::SafetyCategoryThreshold_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::RequestSafetyCheck>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::RequestSafetyCheck_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::RawOutputCheck>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::RawOutputCheck_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::ResponseSafetyCheck>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::ResponseSafetyCheck_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::PartialOutputChecks>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::PartialOutputChecks_globals_},
        #endif
        {::_pbi::FieldAuxEnumData{}, ::optimization_guide::proto::ModelExecutionFeature_internal_data_},
    }},
    {{
    }},
  };
}


inline constexpr FeatureTextSafetyConfiguration::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        safety_category_thresholds_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::FeatureTextSafetyConfiguration,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.safety_category_thresholds_)>()
         }
        ,
        allowed_languages_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::FeatureTextSafetyConfiguration,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.allowed_languages_)>()
         }
        ,
        request_check_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::FeatureTextSafetyConfiguration,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.request_check_)>()
         }
        ,
        response_check_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::FeatureTextSafetyConfiguration,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.response_check_)>()
         }
        ,
        raw_output_check_{nullptr},
        partial_output_checks_{nullptr},
        feature_{static_cast< ::optimization_guide::proto::ModelExecutionFeature >(0)},
        only_cancel_unsafe_response_on_complete_{false} {}

template <typename>
constexpr FeatureTextSafetyConfiguration::FeatureTextSafetyConfiguration(::_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 FeatureTextSafetyConfiguration::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) FeatureTextSafetyConfiguration(arena);
}
constexpr auto FeatureTextSafetyConfiguration::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(FeatureTextSafetyConfiguration), alignof(FeatureTextSafetyConfiguration));
}
constexpr auto FeatureTextSafetyConfiguration::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
          &FeatureTextSafetyConfiguration::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<FeatureTextSafetyConfiguration>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &FeatureTextSafetyConfiguration::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<FeatureTextSafetyConfiguration>(), &FeatureTextSafetyConfiguration::ByteSizeLong,
              &FeatureTextSafetyConfiguration::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_._cached_size_),
          true,
      },
      "optimization_guide.proto.FeatureTextSafetyConfiguration",
  };
}
struct FeatureTextSafetyConfigurationGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr FeatureTextSafetyConfigurationGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 FeatureTextSafetyConfiguration_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(FeatureTextSafetyConfiguration::InternalGenerateClassData_(
            _default, &FeatureTextSafetyConfiguration_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<FeatureTextSafetyConfiguration>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~FeatureTextSafetyConfigurationGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) FeatureTextSafetyConfiguration _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<FeatureTextSafetyConfiguration>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfigurationGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

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

constexpr TextSafetyModelMetadata::ParseTableT_ TextSafetyModelMetadata::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(TextSafetyModelMetadata, _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
      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<::optimization_guide::proto::TextSafetyModelMetadata>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // repeated .optimization_guide.proto.FeatureTextSafetyConfiguration feature_text_safety_configurations = 2;
      {::_pbi::TcParser::FastMtR1,
       {18, 0, 0,
        PROTOBUF_FIELD_OFFSET(TextSafetyModelMetadata, _impl_.feature_text_safety_configurations_)}},
      // optional uint32 num_output_categories = 1;
      {::_pbi::TcParser::FastV32S1,
       {8, 1, 0,
        PROTOBUF_FIELD_OFFSET(TextSafetyModelMetadata, _impl_.num_output_categories_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional uint32 num_output_categories = 1;
      {PROTOBUF_FIELD_OFFSET(TextSafetyModelMetadata, _impl_.num_output_categories_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // repeated .optimization_guide.proto.FeatureTextSafetyConfiguration feature_text_safety_configurations = 2;
      {PROTOBUF_FIELD_OFFSET(TextSafetyModelMetadata, _impl_.feature_text_safety_configurations_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::optimization_guide::proto::FeatureTextSafetyConfiguration>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::optimization_guide::proto::FeatureTextSafetyConfiguration_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr TextSafetyModelMetadata::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        feature_text_safety_configurations_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::TextSafetyModelMetadata,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::TextSafetyModelMetadata, _impl_.feature_text_safety_configurations_)>()
         }
        ,
        num_output_categories_{0u} {}

template <typename>
constexpr TextSafetyModelMetadata::TextSafetyModelMetadata(::_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 TextSafetyModelMetadata::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) TextSafetyModelMetadata(arena);
}
constexpr auto TextSafetyModelMetadata::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(TextSafetyModelMetadata), alignof(TextSafetyModelMetadata));
}
constexpr auto TextSafetyModelMetadata::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
          &TextSafetyModelMetadata::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<TextSafetyModelMetadata>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &TextSafetyModelMetadata::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<TextSafetyModelMetadata>(), &TextSafetyModelMetadata::ByteSizeLong,
              &TextSafetyModelMetadata::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(TextSafetyModelMetadata, _impl_._cached_size_),
          true,
      },
      "optimization_guide.proto.TextSafetyModelMetadata",
  };
}
struct TextSafetyModelMetadataGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr TextSafetyModelMetadataGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 TextSafetyModelMetadata_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(TextSafetyModelMetadata::InternalGenerateClassData_(
            _default, &TextSafetyModelMetadata_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<TextSafetyModelMetadata>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~TextSafetyModelMetadataGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) TextSafetyModelMetadata _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<TextSafetyModelMetadata>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(TextSafetyModelMetadataGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST TextSafetyModelMetadataGlobalsTypeInternal TextSafetyModelMetadata_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* TextSafetyModelMetadata_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return TextSafetyModelMetadata_globals_.GetClassData();
#else
  return TextSafetyModelMetadata_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
}  // namespace proto
}  // namespace optimization_guide
namespace optimization_guide {
namespace proto {
PROTOBUF_CONSTINIT const uint32_t CheckInputType_internal_data_[] = {
    196608u, 0u, };
static const char CheckInputType_names[] = {
    "CHECK_INPUT_TYPE_REQUEST"
    "CHECK_INPUT_TYPE_RESPONSE"
    "CHECK_INPUT_TYPE_UNSPECIFIED"
};

static const ::google::protobuf::internal::EnumEntry CheckInputType_entries[] = {
    {{&CheckInputType_names[0], 24}, 1},
    {{&CheckInputType_names[24], 25}, 2},
    {{&CheckInputType_names[49], 28}, 0},
};

static const int CheckInputType_entries_by_number[] = {
    2,  // 0 -> CHECK_INPUT_TYPE_UNSPECIFIED
    0,  // 1 -> CHECK_INPUT_TYPE_REQUEST
    1,  // 2 -> CHECK_INPUT_TYPE_RESPONSE
};

bool CheckInputType_Parse(::absl::string_view name,
                                  CheckInputType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      CheckInputType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<CheckInputType>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    CheckInputType_strings[3] = {};

const ::std::string& CheckInputType_Name(CheckInputType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      CheckInputType_entries, CheckInputType_entries_by_number, 3,
      CheckInputType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(CheckInputType_entries,
                                  CheckInputType_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : CheckInputType_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t RegexFilterType_internal_data_[] = {
    196608u, 0u, };
static const char RegexFilterType_names[] = {
    "REGEX_FILTER_TYPE_BLOCK_ON_MATCH"
    "REGEX_FILTER_TYPE_BLOCK_ON_NO_MATCH"
    "REGEX_FILTER_TYPE_UNSPECIFIED"
};

static const ::google::protobuf::internal::EnumEntry RegexFilterType_entries[] = {
    {{&RegexFilterType_names[0], 32}, 1},
    {{&RegexFilterType_names[32], 35}, 2},
    {{&RegexFilterType_names[67], 29}, 0},
};

static const int RegexFilterType_entries_by_number[] = {
    2,  // 0 -> REGEX_FILTER_TYPE_UNSPECIFIED
    0,  // 1 -> REGEX_FILTER_TYPE_BLOCK_ON_MATCH
    1,  // 2 -> REGEX_FILTER_TYPE_BLOCK_ON_NO_MATCH
};

bool RegexFilterType_Parse(::absl::string_view name,
                                  RegexFilterType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      RegexFilterType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<RegexFilterType>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    RegexFilterType_strings[3] = {};

const ::std::string& RegexFilterType_Name(RegexFilterType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      RegexFilterType_entries, RegexFilterType_entries_by_number, 3,
      RegexFilterType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(RegexFilterType_entries,
                                  RegexFilterType_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : RegexFilterType_strings[idx].get();
}
// ===================================================================

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

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

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  TextSafetyModelMetadata* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  _impl_.num_output_categories_ = from._impl_.num_output_categories_;

  // @@protoc_insertion_point(copy_constructor:optimization_guide.proto.TextSafetyModelMetadata)
}
PROTOBUF_NDEBUG_INLINE TextSafetyModelMetadata::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        feature_text_safety_configurations_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::TextSafetyModelMetadata,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::TextSafetyModelMetadata, _impl_.feature_text_safety_configurations_)>()
         }
     {}

inline void TextSafetyModelMetadata::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.num_output_categories_ = {};
}
TextSafetyModelMetadata::~TextSafetyModelMetadata() {
  // @@protoc_insertion_point(destructor:optimization_guide.proto.TextSafetyModelMetadata)
  SharedDtor(*this);
}
inline void TextSafetyModelMetadata::SharedDtor(MessageLite& self) {
  TextSafetyModelMetadata& this_ = static_cast<TextSafetyModelMetadata&>(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 TextSafetyModelMetadata_class_data_ =
    TextSafetyModelMetadata::InternalGenerateClassData_(TextSafetyModelMetadata_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
TextSafetyModelMetadata::GetClassData() const {
  return TextSafetyModelMetadata_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
TextSafetyModelMetadata::GetClassData() const {
  return TextSafetyModelMetadata_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const TextSafetyModelMetadata::ParseTableT_
    TextSafetyModelMetadata::_table_ =
        TextSafetyModelMetadata::InternalGenerateParseTable_(TextSafetyModelMetadata_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void TextSafetyModelMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:optimization_guide.proto.TextSafetyModelMetadata)
  ::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_.feature_text_safety_configurations_.Clear();
  }
  _impl_.num_output_categories_ = 0u;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

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

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional uint32 num_output_categories = 1;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        1, this_._internal_num_output_categories(), target);
  }

  // repeated .optimization_guide.proto.FeatureTextSafetyConfiguration feature_text_safety_configurations = 2;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_feature_text_safety_configurations_size());
         i < n; i++) {
      const auto& repfield = this_._internal_feature_text_safety_configurations().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              2, repfield, repfield.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:optimization_guide.proto.TextSafetyModelMetadata)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t TextSafetyModelMetadata::ByteSizeLong(const MessageLite& base) {
  const TextSafetyModelMetadata& this_ = static_cast<const TextSafetyModelMetadata&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t TextSafetyModelMetadata::ByteSizeLong() const {
  const TextSafetyModelMetadata& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:optimization_guide.proto.TextSafetyModelMetadata)
  ::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)) {
    // repeated .optimization_guide.proto.FeatureTextSafetyConfiguration feature_text_safety_configurations = 2;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_feature_text_safety_configurations_size();
      for (const auto& msg : this_._internal_feature_text_safety_configurations()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional uint32 num_output_categories = 1;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_num_output_categories());
    }
  }
  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 TextSafetyModelMetadata::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<TextSafetyModelMetadata*>(&to_msg);
  auto& from = static_cast<const TextSafetyModelMetadata&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:optimization_guide.proto.TextSafetyModelMetadata)
  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->_internal_mutable_feature_text_safety_configurations()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_feature_text_safety_configurations());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.num_output_categories_ = from._impl_.num_output_categories_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void TextSafetyModelMetadata::CopyFrom(const TextSafetyModelMetadata& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:optimization_guide.proto.TextSafetyModelMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void TextSafetyModelMetadata::InternalSwap(TextSafetyModelMetadata* 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_.feature_text_safety_configurations_.InternalSwap(&other->_impl_.feature_text_safety_configurations_);
  swap(_impl_.num_output_categories_, other->_impl_.num_output_categories_);
}

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

void CheckInput::clear_templates() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.templates_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
CheckInput::CheckInput(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, CheckInput_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:optimization_guide.proto.CheckInput)
}
PROTOBUF_NDEBUG_INLINE CheckInput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::optimization_guide::proto::CheckInput& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        templates_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::optimization_guide::proto::CheckInput,
              PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::CheckInput, _impl_.templates_)>()
          , from.templates_
        }
     {}

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

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  CheckInput* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  _impl_.input_type_ = from._impl_.input_type_;

  // @@protoc_insertion_point(copy_constructor:optimization_guide.proto.CheckInput)
}
PROTOBUF_NDEBUG_INLINE CheckInput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        templates_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::CheckInput,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::CheckInput, _impl_.templates_)>()
         }
     {}

inline void CheckInput::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.input_type_ = {};
}
CheckInput::~CheckInput() {
  // @@protoc_insertion_point(destructor:optimization_guide.proto.CheckInput)
  SharedDtor(*this);
}
inline void CheckInput::SharedDtor(MessageLite& self) {
  CheckInput& this_ = static_cast<CheckInput&>(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 CheckInput_class_data_ =
    CheckInput::InternalGenerateClassData_(CheckInput_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
CheckInput::GetClassData() const {
  return CheckInput_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
CheckInput::GetClassData() const {
  return CheckInput_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const CheckInput::ParseTableT_
    CheckInput::_table_ =
        CheckInput::InternalGenerateParseTable_(CheckInput_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void CheckInput::Clear() {
// @@protoc_insertion_point(message_clear_start:optimization_guide.proto.CheckInput)
  ::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_.templates_.Clear();
  }
  _impl_.input_type_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

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

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .optimization_guide.proto.CheckInputType input_type = 1;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this_._internal_input_type(), target);
  }

  // repeated .optimization_guide.proto.SubstitutedString templates = 2;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_templates_size());
         i < n; i++) {
      const auto& repfield = this_._internal_templates().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              2, repfield, repfield.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:optimization_guide.proto.CheckInput)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t CheckInput::ByteSizeLong(const MessageLite& base) {
  const CheckInput& this_ = static_cast<const CheckInput&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t CheckInput::ByteSizeLong() const {
  const CheckInput& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:optimization_guide.proto.CheckInput)
  ::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)) {
    // repeated .optimization_guide.proto.SubstitutedString templates = 2;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_templates_size();
      for (const auto& msg : this_._internal_templates()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional .optimization_guide.proto.CheckInputType input_type = 1;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_input_type());
    }
  }
  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 CheckInput::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<CheckInput*>(&to_msg);
  auto& from = static_cast<const CheckInput&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:optimization_guide.proto.CheckInput)
  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->_internal_mutable_templates()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_templates());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.input_type_ = from._impl_.input_type_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void CheckInput::CopyFrom(const CheckInput& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:optimization_guide.proto.CheckInput)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void CheckInput::InternalSwap(CheckInput* 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_.templates_.InternalSwap(&other->_impl_.templates_);
  swap(_impl_.input_type_, other->_impl_.input_type_);
}

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

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

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

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SafetyCategoryThreshold* 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_, output_index_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, output_index_),
           offsetof(Impl_, threshold_) -
               offsetof(Impl_, output_index_) +
               sizeof(Impl_::threshold_));

  // @@protoc_insertion_point(copy_constructor:optimization_guide.proto.SafetyCategoryThreshold)
}
PROTOBUF_NDEBUG_INLINE SafetyCategoryThreshold::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        category_label_(arena) {}

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

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite SafetyCategoryThreshold_class_data_ =
    SafetyCategoryThreshold::InternalGenerateClassData_(SafetyCategoryThreshold_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SafetyCategoryThreshold::GetClassData() const {
  return SafetyCategoryThreshold_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SafetyCategoryThreshold::GetClassData() const {
  return SafetyCategoryThreshold_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const SafetyCategoryThreshold::ParseTableT_
    SafetyCategoryThreshold::_table_ =
        SafetyCategoryThreshold::InternalGenerateParseTable_(SafetyCategoryThreshold_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void SafetyCategoryThreshold::Clear() {
// @@protoc_insertion_point(message_clear_start:optimization_guide.proto.SafetyCategoryThreshold)
  ::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_.category_label_.ClearNonDefaultToEmpty();
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00000006U)) {
    ::memset(&_impl_.output_index_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.threshold_) -
        reinterpret_cast<char*>(&_impl_.output_index_)) + sizeof(_impl_.threshold_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

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

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional string category_label = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    const ::std::string& _s = this_._internal_category_label();
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // optional uint32 output_index = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        2, this_._internal_output_index(), target);
  }

  // optional float threshold = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        3, this_._internal_threshold(), 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:optimization_guide.proto.SafetyCategoryThreshold)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t SafetyCategoryThreshold::ByteSizeLong(const MessageLite& base) {
  const SafetyCategoryThreshold& this_ = static_cast<const SafetyCategoryThreshold&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t SafetyCategoryThreshold::ByteSizeLong() const {
  const SafetyCategoryThreshold& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:optimization_guide.proto.SafetyCategoryThreshold)
  ::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)) {
    // optional string category_label = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_category_label());
    }
    // optional uint32 output_index = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_output_index());
    }
  }
  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 SafetyCategoryThreshold::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<SafetyCategoryThreshold*>(&to_msg);
  auto& from = static_cast<const SafetyCategoryThreshold&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:optimization_guide.proto.SafetyCategoryThreshold)
  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_set_category_label(from._internal_category_label());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.output_index_ = from._impl_.output_index_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.threshold_ = from._impl_.threshold_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void SafetyCategoryThreshold::CopyFrom(const SafetyCategoryThreshold& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:optimization_guide.proto.SafetyCategoryThreshold)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void SafetyCategoryThreshold::InternalSwap(SafetyCategoryThreshold* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.category_label_, &other->_impl_.category_label_, arena);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SafetyCategoryThreshold, _impl_.threshold_)
      + sizeof(SafetyCategoryThreshold::_impl_.threshold_)
      - PROTOBUF_FIELD_OFFSET(SafetyCategoryThreshold, _impl_.output_index_)>(
          reinterpret_cast<char*>(&_impl_.output_index_),
          reinterpret_cast<char*>(&other->_impl_.output_index_));
}

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

LanguageCheck::LanguageCheck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, LanguageCheck_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:optimization_guide.proto.LanguageCheck)
}
LanguageCheck::LanguageCheck(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LanguageCheck& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, LanguageCheck_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 LanguageCheck::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void LanguageCheck::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, confidence_threshold_),
           0,
           offsetof(Impl_, partial_threshold_) -
               offsetof(Impl_, confidence_threshold_) +
               sizeof(Impl_::partial_threshold_));
}
LanguageCheck::~LanguageCheck() {
  // @@protoc_insertion_point(destructor:optimization_guide.proto.LanguageCheck)
  SharedDtor(*this);
}
inline void LanguageCheck::SharedDtor(MessageLite& self) {
  LanguageCheck& this_ = static_cast<LanguageCheck&>(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 LanguageCheck_class_data_ =
    LanguageCheck::InternalGenerateClassData_(LanguageCheck_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
LanguageCheck::GetClassData() const {
  return LanguageCheck_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
LanguageCheck::GetClassData() const {
  return LanguageCheck_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const LanguageCheck::ParseTableT_
    LanguageCheck::_table_ =
        LanguageCheck::InternalGenerateParseTable_(LanguageCheck_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void LanguageCheck::Clear() {
// @@protoc_insertion_point(message_clear_start:optimization_guide.proto.LanguageCheck)
  ::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_.confidence_threshold_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.partial_threshold_) -
        reinterpret_cast<char*>(&_impl_.confidence_threshold_)) + sizeof(_impl_.partial_threshold_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

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

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional double confidence_threshold = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        1, this_._internal_confidence_threshold(), target);
  }

  // optional double partial_threshold = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        2, this_._internal_partial_threshold(), 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:optimization_guide.proto.LanguageCheck)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t LanguageCheck::ByteSizeLong(const MessageLite& base) {
  const LanguageCheck& this_ = static_cast<const LanguageCheck&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t LanguageCheck::ByteSizeLong() const {
  const LanguageCheck& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:optimization_guide.proto.LanguageCheck)
  ::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) * 9;
  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 LanguageCheck::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<LanguageCheck*>(&to_msg);
  auto& from = static_cast<const LanguageCheck&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:optimization_guide.proto.LanguageCheck)
  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_.confidence_threshold_ = from._impl_.confidence_threshold_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.partial_threshold_ = from._impl_.partial_threshold_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void LanguageCheck::CopyFrom(const LanguageCheck& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:optimization_guide.proto.LanguageCheck)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void LanguageCheck::InternalSwap(LanguageCheck* 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(LanguageCheck, _impl_.partial_threshold_)
      + sizeof(LanguageCheck::_impl_.partial_threshold_)
      - PROTOBUF_FIELD_OFFSET(LanguageCheck, _impl_.confidence_threshold_)>(
          reinterpret_cast<char*>(&_impl_.confidence_threshold_),
          reinterpret_cast<char*>(&other->_impl_.confidence_threshold_));
}

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

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

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

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  RegexFilter* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  _impl_.type_ = from._impl_.type_;

  // @@protoc_insertion_point(copy_constructor:optimization_guide.proto.RegexFilter)
}
PROTOBUF_NDEBUG_INLINE RegexFilter::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        regex_(arena) {}

inline void RegexFilter::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.type_ = {};
}
RegexFilter::~RegexFilter() {
  // @@protoc_insertion_point(destructor:optimization_guide.proto.RegexFilter)
  SharedDtor(*this);
}
inline void RegexFilter::SharedDtor(MessageLite& self) {
  RegexFilter& this_ = static_cast<RegexFilter&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.regex_.Destroy();
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite RegexFilter_class_data_ =
    RegexFilter::InternalGenerateClassData_(RegexFilter_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
RegexFilter::GetClassData() const {
  return RegexFilter_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
RegexFilter::GetClassData() const {
  return RegexFilter_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const RegexFilter::ParseTableT_
    RegexFilter::_table_ =
        RegexFilter::InternalGenerateParseTable_(RegexFilter_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void RegexFilter::Clear() {
// @@protoc_insertion_point(message_clear_start:optimization_guide.proto.RegexFilter)
  ::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_.regex_.ClearNonDefaultToEmpty();
  }
  _impl_.type_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

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

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .optimization_guide.proto.RegexFilterType type = 1;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this_._internal_type(), target);
  }

  // optional string regex = 2;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    const ::std::string& _s = this_._internal_regex();
    target = stream->WriteStringMaybeAliased(2, _s, 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:optimization_guide.proto.RegexFilter)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t RegexFilter::ByteSizeLong(const MessageLite& base) {
  const RegexFilter& this_ = static_cast<const RegexFilter&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t RegexFilter::ByteSizeLong() const {
  const RegexFilter& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:optimization_guide.proto.RegexFilter)
  ::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 string regex = 2;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_regex());
    }
    // optional .optimization_guide.proto.RegexFilterType type = 1;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_type());
    }
  }
  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 RegexFilter::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<RegexFilter*>(&to_msg);
  auto& from = static_cast<const RegexFilter&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:optimization_guide.proto.RegexFilter)
  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->_internal_set_regex(from._internal_regex());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.type_ = from._impl_.type_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void RegexFilter::CopyFrom(const RegexFilter& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:optimization_guide.proto.RegexFilter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void RegexFilter::InternalSwap(RegexFilter* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.regex_, &other->_impl_.regex_, arena);
  swap(_impl_.type_, other->_impl_.type_);
}

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

void RequestSafetyCheck::clear_input_template() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_template_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
RequestSafetyCheck::RequestSafetyCheck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, RequestSafetyCheck_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:optimization_guide.proto.RequestSafetyCheck)
}
PROTOBUF_NDEBUG_INLINE RequestSafetyCheck::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::optimization_guide::proto::RequestSafetyCheck& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        input_template_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::optimization_guide::proto::RequestSafetyCheck,
              PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::RequestSafetyCheck, _impl_.input_template_)>()
          , from.input_template_
        }
        ,
        safety_category_thresholds_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::optimization_guide::proto::RequestSafetyCheck,
              PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::RequestSafetyCheck, _impl_.safety_category_thresholds_)>()
          , from.safety_category_thresholds_
        }
     {}

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

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  RequestSafetyCheck* 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_.language_check_ = (CheckHasBit(cached_has_bits, 0x00000004U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.language_check_)
                : nullptr;
  _impl_.regex_filter_ = (CheckHasBit(cached_has_bits, 0x00000008U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.regex_filter_)
                : nullptr;
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, check_language_only_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, check_language_only_),
           offsetof(Impl_, ignore_language_result_) -
               offsetof(Impl_, check_language_only_) +
               sizeof(Impl_::ignore_language_result_));

  // @@protoc_insertion_point(copy_constructor:optimization_guide.proto.RequestSafetyCheck)
}
PROTOBUF_NDEBUG_INLINE RequestSafetyCheck::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        input_template_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::RequestSafetyCheck,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::RequestSafetyCheck, _impl_.input_template_)>()
         }
        ,
        safety_category_thresholds_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::RequestSafetyCheck,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::RequestSafetyCheck, _impl_.safety_category_thresholds_)>()
         }
     {}

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

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite RequestSafetyCheck_class_data_ =
    RequestSafetyCheck::InternalGenerateClassData_(RequestSafetyCheck_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
RequestSafetyCheck::GetClassData() const {
  return RequestSafetyCheck_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
RequestSafetyCheck::GetClassData() const {
  return RequestSafetyCheck_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const RequestSafetyCheck::ParseTableT_
    RequestSafetyCheck::_table_ =
        RequestSafetyCheck::InternalGenerateParseTable_(RequestSafetyCheck_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void RequestSafetyCheck::Clear() {
// @@protoc_insertion_point(message_clear_start:optimization_guide.proto.RequestSafetyCheck)
  ::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)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _impl_.input_template_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _impl_.safety_category_thresholds_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(_impl_.language_check_ != nullptr);
      _impl_.language_check_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      ABSL_DCHECK(_impl_.regex_filter_ != nullptr);
      _impl_.regex_filter_->Clear();
    }
  }
  ::memset(&_impl_.check_language_only_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.ignore_language_result_) -
      reinterpret_cast<char*>(&_impl_.check_language_only_)) + sizeof(_impl_.ignore_language_result_));
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

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

  cached_has_bits = this_._impl_._has_bits_[0];
  // repeated .optimization_guide.proto.SubstitutedString input_template = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_input_template_size());
         i < n; i++) {
      const auto& repfield = this_._internal_input_template().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              1, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_safety_category_thresholds_size());
         i < n; i++) {
      const auto& repfield = this_._internal_safety_category_thresholds().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              2, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // optional bool check_language_only = 3;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        3, this_._internal_check_language_only(), target);
  }

  // optional bool ignore_language_result = 4;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        4, this_._internal_ignore_language_result(), target);
  }

  // optional .optimization_guide.proto.LanguageCheck language_check = 5;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        5, *this_._impl_.language_check_, this_._impl_.language_check_->GetCachedSize(), target,
        stream);
  }

  // optional .optimization_guide.proto.RegexFilter regex_filter = 6;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        6, *this_._impl_.regex_filter_, this_._impl_.regex_filter_->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:optimization_guide.proto.RequestSafetyCheck)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t RequestSafetyCheck::ByteSizeLong(const MessageLite& base) {
  const RequestSafetyCheck& this_ = static_cast<const RequestSafetyCheck&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t RequestSafetyCheck::ByteSizeLong() const {
  const RequestSafetyCheck& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:optimization_guide.proto.RequestSafetyCheck)
  ::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(0x00000030U & cached_has_bits) * 2;
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    // repeated .optimization_guide.proto.SubstitutedString input_template = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_input_template_size();
      for (const auto& msg : this_._internal_input_template()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1UL * this_._internal_safety_category_thresholds_size();
      for (const auto& msg : this_._internal_safety_category_thresholds()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional .optimization_guide.proto.LanguageCheck language_check = 5;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.language_check_);
    }
    // optional .optimization_guide.proto.RegexFilter regex_filter = 6;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.regex_filter_);
    }
  }
  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 RequestSafetyCheck::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<RequestSafetyCheck*>(&to_msg);
  auto& from = static_cast<const RequestSafetyCheck&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:optimization_guide.proto.RequestSafetyCheck)
  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, 0x0000003fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_input_template()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_input_template());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_internal_mutable_safety_category_thresholds()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_safety_category_thresholds());
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(from._impl_.language_check_ != nullptr);
      if (_this->_impl_.language_check_ == nullptr) {
        _this->_impl_.language_check_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.language_check_);
      } else {
        _this->_impl_.language_check_->MergeFrom(*from._impl_.language_check_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      ABSL_DCHECK(from._impl_.regex_filter_ != nullptr);
      if (_this->_impl_.regex_filter_ == nullptr) {
        _this->_impl_.regex_filter_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.regex_filter_);
      } else {
        _this->_impl_.regex_filter_->MergeFrom(*from._impl_.regex_filter_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.check_language_only_ = from._impl_.check_language_only_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      _this->_impl_.ignore_language_result_ = from._impl_.ignore_language_result_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void RequestSafetyCheck::CopyFrom(const RequestSafetyCheck& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:optimization_guide.proto.RequestSafetyCheck)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void RequestSafetyCheck::InternalSwap(RequestSafetyCheck* 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_.input_template_.InternalSwap(&other->_impl_.input_template_);
  _impl_.safety_category_thresholds_.InternalSwap(&other->_impl_.safety_category_thresholds_);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.ignore_language_result_)
      + sizeof(RequestSafetyCheck::_impl_.ignore_language_result_)
      - PROTOBUF_FIELD_OFFSET(RequestSafetyCheck, _impl_.language_check_)>(
          reinterpret_cast<char*>(&_impl_.language_check_),
          reinterpret_cast<char*>(&other->_impl_.language_check_));
}

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

PartialOutputChecks::PartialOutputChecks(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, PartialOutputChecks_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:optimization_guide.proto.PartialOutputChecks)
}
PartialOutputChecks::PartialOutputChecks(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PartialOutputChecks& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, PartialOutputChecks_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 PartialOutputChecks::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void PartialOutputChecks::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, minimum_tokens_),
           0,
           offsetof(Impl_, token_interval_) -
               offsetof(Impl_, minimum_tokens_) +
               sizeof(Impl_::token_interval_));
}
PartialOutputChecks::~PartialOutputChecks() {
  // @@protoc_insertion_point(destructor:optimization_guide.proto.PartialOutputChecks)
  SharedDtor(*this);
}
inline void PartialOutputChecks::SharedDtor(MessageLite& self) {
  PartialOutputChecks& this_ = static_cast<PartialOutputChecks&>(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 PartialOutputChecks_class_data_ =
    PartialOutputChecks::InternalGenerateClassData_(PartialOutputChecks_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
PartialOutputChecks::GetClassData() const {
  return PartialOutputChecks_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
PartialOutputChecks::GetClassData() const {
  return PartialOutputChecks_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const PartialOutputChecks::ParseTableT_
    PartialOutputChecks::_table_ =
        PartialOutputChecks::InternalGenerateParseTable_(PartialOutputChecks_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void PartialOutputChecks::Clear() {
// @@protoc_insertion_point(message_clear_start:optimization_guide.proto.PartialOutputChecks)
  ::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_.minimum_tokens_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.token_interval_) -
        reinterpret_cast<char*>(&_impl_.minimum_tokens_)) + sizeof(_impl_.token_interval_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

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

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional uint32 minimum_tokens = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        1, this_._internal_minimum_tokens(), target);
  }

  // optional uint32 token_interval = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        2, this_._internal_token_interval(), 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:optimization_guide.proto.PartialOutputChecks)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t PartialOutputChecks::ByteSizeLong(const MessageLite& base) {
  const PartialOutputChecks& this_ = static_cast<const PartialOutputChecks&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t PartialOutputChecks::ByteSizeLong() const {
  const PartialOutputChecks& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:optimization_guide.proto.PartialOutputChecks)
  ::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 uint32 minimum_tokens = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_minimum_tokens());
    }
    // optional uint32 token_interval = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_token_interval());
    }
  }
  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 PartialOutputChecks::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<PartialOutputChecks*>(&to_msg);
  auto& from = static_cast<const PartialOutputChecks&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:optimization_guide.proto.PartialOutputChecks)
  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_.minimum_tokens_ = from._impl_.minimum_tokens_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.token_interval_ = from._impl_.token_interval_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void PartialOutputChecks::CopyFrom(const PartialOutputChecks& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:optimization_guide.proto.PartialOutputChecks)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void PartialOutputChecks::InternalSwap(PartialOutputChecks* 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(PartialOutputChecks, _impl_.token_interval_)
      + sizeof(PartialOutputChecks::_impl_.token_interval_)
      - PROTOBUF_FIELD_OFFSET(PartialOutputChecks, _impl_.minimum_tokens_)>(
          reinterpret_cast<char*>(&_impl_.minimum_tokens_),
          reinterpret_cast<char*>(&other->_impl_.minimum_tokens_));
}

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

void RawOutputCheck::clear_input_template() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_template_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
RawOutputCheck::RawOutputCheck(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, RawOutputCheck_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:optimization_guide.proto.RawOutputCheck)
}
PROTOBUF_NDEBUG_INLINE RawOutputCheck::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::optimization_guide::proto::RawOutputCheck& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        input_template_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::optimization_guide::proto::RawOutputCheck,
              PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::RawOutputCheck, _impl_.input_template_)>()
          , from.input_template_
        }
     {}

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

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  RawOutputCheck* 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_.language_check_ = (CheckHasBit(cached_has_bits, 0x00000002U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.language_check_)
                : nullptr;
  _impl_.regex_filter_ = (CheckHasBit(cached_has_bits, 0x00000004U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.regex_filter_)
                : nullptr;

  // @@protoc_insertion_point(copy_constructor:optimization_guide.proto.RawOutputCheck)
}
PROTOBUF_NDEBUG_INLINE RawOutputCheck::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        input_template_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::RawOutputCheck,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::RawOutputCheck, _impl_.input_template_)>()
         }
     {}

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

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite RawOutputCheck_class_data_ =
    RawOutputCheck::InternalGenerateClassData_(RawOutputCheck_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
RawOutputCheck::GetClassData() const {
  return RawOutputCheck_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
RawOutputCheck::GetClassData() const {
  return RawOutputCheck_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const RawOutputCheck::ParseTableT_
    RawOutputCheck::_table_ =
        RawOutputCheck::InternalGenerateParseTable_(RawOutputCheck_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void RawOutputCheck::Clear() {
// @@protoc_insertion_point(message_clear_start:optimization_guide.proto.RawOutputCheck)
  ::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, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _impl_.input_template_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(_impl_.language_check_ != nullptr);
      _impl_.language_check_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(_impl_.regex_filter_ != nullptr);
      _impl_.regex_filter_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

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

  cached_has_bits = this_._impl_._has_bits_[0];
  // repeated .optimization_guide.proto.SubstitutedString input_template = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_input_template_size());
         i < n; i++) {
      const auto& repfield = this_._internal_input_template().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              1, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // optional .optimization_guide.proto.LanguageCheck language_check = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        2, *this_._impl_.language_check_, this_._impl_.language_check_->GetCachedSize(), target,
        stream);
  }

  // optional .optimization_guide.proto.RegexFilter regex_filter = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        3, *this_._impl_.regex_filter_, this_._impl_.regex_filter_->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:optimization_guide.proto.RawOutputCheck)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t RawOutputCheck::ByteSizeLong(const MessageLite& base) {
  const RawOutputCheck& this_ = static_cast<const RawOutputCheck&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t RawOutputCheck::ByteSizeLong() const {
  const RawOutputCheck& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:optimization_guide.proto.RawOutputCheck)
  ::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)) {
    // repeated .optimization_guide.proto.SubstitutedString input_template = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_input_template_size();
      for (const auto& msg : this_._internal_input_template()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional .optimization_guide.proto.LanguageCheck language_check = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.language_check_);
    }
    // optional .optimization_guide.proto.RegexFilter regex_filter = 3;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.regex_filter_);
    }
  }
  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 RawOutputCheck::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<RawOutputCheck*>(&to_msg);
  auto& from = static_cast<const RawOutputCheck&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:optimization_guide.proto.RawOutputCheck)
  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_input_template()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_input_template());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(from._impl_.language_check_ != nullptr);
      if (_this->_impl_.language_check_ == nullptr) {
        _this->_impl_.language_check_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.language_check_);
      } else {
        _this->_impl_.language_check_->MergeFrom(*from._impl_.language_check_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(from._impl_.regex_filter_ != nullptr);
      if (_this->_impl_.regex_filter_ == nullptr) {
        _this->_impl_.regex_filter_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.regex_filter_);
      } else {
        _this->_impl_.regex_filter_->MergeFrom(*from._impl_.regex_filter_);
      }
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void RawOutputCheck::CopyFrom(const RawOutputCheck& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:optimization_guide.proto.RawOutputCheck)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void RawOutputCheck::InternalSwap(RawOutputCheck* 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_.input_template_.InternalSwap(&other->_impl_.input_template_);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RawOutputCheck, _impl_.regex_filter_)
      + sizeof(RawOutputCheck::_impl_.regex_filter_)
      - PROTOBUF_FIELD_OFFSET(RawOutputCheck, _impl_.language_check_)>(
          reinterpret_cast<char*>(&_impl_.language_check_),
          reinterpret_cast<char*>(&other->_impl_.language_check_));
}

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

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

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

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  ResponseSafetyCheck* 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_.language_check_ = (CheckHasBit(cached_has_bits, 0x00000004U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.language_check_)
                : nullptr;
  _impl_.regex_filter_ = (CheckHasBit(cached_has_bits, 0x00000008U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.regex_filter_)
                : nullptr;
  _impl_.ignore_language_result_ = from._impl_.ignore_language_result_;

  // @@protoc_insertion_point(copy_constructor:optimization_guide.proto.ResponseSafetyCheck)
}
PROTOBUF_NDEBUG_INLINE ResponseSafetyCheck::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        inputs_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::ResponseSafetyCheck,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::ResponseSafetyCheck, _impl_.inputs_)>()
         }
        ,
        safety_category_thresholds_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::ResponseSafetyCheck,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::ResponseSafetyCheck, _impl_.safety_category_thresholds_)>()
         }
     {}

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

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite ResponseSafetyCheck_class_data_ =
    ResponseSafetyCheck::InternalGenerateClassData_(ResponseSafetyCheck_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
ResponseSafetyCheck::GetClassData() const {
  return ResponseSafetyCheck_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
ResponseSafetyCheck::GetClassData() const {
  return ResponseSafetyCheck_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ResponseSafetyCheck::ParseTableT_
    ResponseSafetyCheck::_table_ =
        ResponseSafetyCheck::InternalGenerateParseTable_(ResponseSafetyCheck_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void ResponseSafetyCheck::Clear() {
// @@protoc_insertion_point(message_clear_start:optimization_guide.proto.ResponseSafetyCheck)
  ::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)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _impl_.inputs_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _impl_.safety_category_thresholds_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(_impl_.language_check_ != nullptr);
      _impl_.language_check_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      ABSL_DCHECK(_impl_.regex_filter_ != nullptr);
      _impl_.regex_filter_->Clear();
    }
  }
  _impl_.ignore_language_result_ = false;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

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

  cached_has_bits = this_._impl_._has_bits_[0];
  // repeated .optimization_guide.proto.CheckInput inputs = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_inputs_size());
         i < n; i++) {
      const auto& repfield = this_._internal_inputs().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              1, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_safety_category_thresholds_size());
         i < n; i++) {
      const auto& repfield = this_._internal_safety_category_thresholds().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              2, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // optional bool ignore_language_result = 3;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        3, this_._internal_ignore_language_result(), target);
  }

  // optional .optimization_guide.proto.LanguageCheck language_check = 4;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        4, *this_._impl_.language_check_, this_._impl_.language_check_->GetCachedSize(), target,
        stream);
  }

  // optional .optimization_guide.proto.RegexFilter regex_filter = 6;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        6, *this_._impl_.regex_filter_, this_._impl_.regex_filter_->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:optimization_guide.proto.ResponseSafetyCheck)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t ResponseSafetyCheck::ByteSizeLong(const MessageLite& base) {
  const ResponseSafetyCheck& this_ = static_cast<const ResponseSafetyCheck&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t ResponseSafetyCheck::ByteSizeLong() const {
  const ResponseSafetyCheck& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:optimization_guide.proto.ResponseSafetyCheck)
  ::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>(0x00000010U & cached_has_bits) * 2;
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    // repeated .optimization_guide.proto.CheckInput inputs = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_inputs_size();
      for (const auto& msg : this_._internal_inputs()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1UL * this_._internal_safety_category_thresholds_size();
      for (const auto& msg : this_._internal_safety_category_thresholds()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional .optimization_guide.proto.LanguageCheck language_check = 4;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.language_check_);
    }
    // optional .optimization_guide.proto.RegexFilter regex_filter = 6;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.regex_filter_);
    }
  }
  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 ResponseSafetyCheck::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<ResponseSafetyCheck*>(&to_msg);
  auto& from = static_cast<const ResponseSafetyCheck&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:optimization_guide.proto.ResponseSafetyCheck)
  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, 0x0000001fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_inputs()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_inputs());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_internal_mutable_safety_category_thresholds()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_safety_category_thresholds());
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(from._impl_.language_check_ != nullptr);
      if (_this->_impl_.language_check_ == nullptr) {
        _this->_impl_.language_check_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.language_check_);
      } else {
        _this->_impl_.language_check_->MergeFrom(*from._impl_.language_check_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      ABSL_DCHECK(from._impl_.regex_filter_ != nullptr);
      if (_this->_impl_.regex_filter_ == nullptr) {
        _this->_impl_.regex_filter_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.regex_filter_);
      } else {
        _this->_impl_.regex_filter_->MergeFrom(*from._impl_.regex_filter_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.ignore_language_result_ = from._impl_.ignore_language_result_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void ResponseSafetyCheck::CopyFrom(const ResponseSafetyCheck& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:optimization_guide.proto.ResponseSafetyCheck)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void ResponseSafetyCheck::InternalSwap(ResponseSafetyCheck* 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_.inputs_.InternalSwap(&other->_impl_.inputs_);
  _impl_.safety_category_thresholds_.InternalSwap(&other->_impl_.safety_category_thresholds_);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.ignore_language_result_)
      + sizeof(ResponseSafetyCheck::_impl_.ignore_language_result_)
      - PROTOBUF_FIELD_OFFSET(ResponseSafetyCheck, _impl_.language_check_)>(
          reinterpret_cast<char*>(&_impl_.language_check_),
          reinterpret_cast<char*>(&other->_impl_.language_check_));
}

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

FeatureTextSafetyConfiguration::FeatureTextSafetyConfiguration(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, FeatureTextSafetyConfiguration_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:optimization_guide.proto.FeatureTextSafetyConfiguration)
}
PROTOBUF_NDEBUG_INLINE FeatureTextSafetyConfiguration::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::optimization_guide::proto::FeatureTextSafetyConfiguration& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        safety_category_thresholds_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::optimization_guide::proto::FeatureTextSafetyConfiguration,
              PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.safety_category_thresholds_)>()
          , from.safety_category_thresholds_
        }
        ,
        allowed_languages_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::optimization_guide::proto::FeatureTextSafetyConfiguration,
              PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.allowed_languages_)>()
          , from.allowed_languages_
        }
        ,
        request_check_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::optimization_guide::proto::FeatureTextSafetyConfiguration,
              PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.request_check_)>()
          , from.request_check_
        }
        ,
        response_check_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::optimization_guide::proto::FeatureTextSafetyConfiguration,
              PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.response_check_)>()
          , from.response_check_
        }
     {}

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

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  FeatureTextSafetyConfiguration* 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_.raw_output_check_ = (CheckHasBit(cached_has_bits, 0x00000010U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.raw_output_check_)
                : nullptr;
  _impl_.partial_output_checks_ = (CheckHasBit(cached_has_bits, 0x00000020U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.partial_output_checks_)
                : nullptr;
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, feature_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, feature_),
           offsetof(Impl_, only_cancel_unsafe_response_on_complete_) -
               offsetof(Impl_, feature_) +
               sizeof(Impl_::only_cancel_unsafe_response_on_complete_));

  // @@protoc_insertion_point(copy_constructor:optimization_guide.proto.FeatureTextSafetyConfiguration)
}
PROTOBUF_NDEBUG_INLINE FeatureTextSafetyConfiguration::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        safety_category_thresholds_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::FeatureTextSafetyConfiguration,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.safety_category_thresholds_)>()
         }
        ,
        allowed_languages_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::FeatureTextSafetyConfiguration,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.allowed_languages_)>()
         }
        ,
        request_check_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::FeatureTextSafetyConfiguration,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.request_check_)>()
         }
        ,
        response_check_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::optimization_guide::proto::FeatureTextSafetyConfiguration,
            PROTOBUF_FIELD_OFFSET(::optimization_guide::proto::FeatureTextSafetyConfiguration, _impl_.response_check_)>()
         }
     {}

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

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite FeatureTextSafetyConfiguration_class_data_ =
    FeatureTextSafetyConfiguration::InternalGenerateClassData_(FeatureTextSafetyConfiguration_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FeatureTextSafetyConfiguration::GetClassData() const {
  return FeatureTextSafetyConfiguration_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FeatureTextSafetyConfiguration::GetClassData() const {
  return FeatureTextSafetyConfiguration_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const FeatureTextSafetyConfiguration::ParseTableT_
    FeatureTextSafetyConfiguration::_table_ =
        FeatureTextSafetyConfiguration::InternalGenerateParseTable_(FeatureTextSafetyConfiguration_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void FeatureTextSafetyConfiguration::Clear() {
// @@protoc_insertion_point(message_clear_start:optimization_guide.proto.FeatureTextSafetyConfiguration)
  ::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, 0x0000003fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _impl_.safety_category_thresholds_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _impl_.allowed_languages_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _impl_.request_check_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _impl_.response_check_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      ABSL_DCHECK(_impl_.raw_output_check_ != nullptr);
      _impl_.raw_output_check_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      ABSL_DCHECK(_impl_.partial_output_checks_ != nullptr);
      _impl_.partial_output_checks_->Clear();
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x000000c0U)) {
    ::memset(&_impl_.feature_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.only_cancel_unsafe_response_on_complete_) -
        reinterpret_cast<char*>(&_impl_.feature_)) + sizeof(_impl_.only_cancel_unsafe_response_on_complete_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

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

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .optimization_guide.proto.ModelExecutionFeature feature = 1;
  if (CheckHasBit(cached_has_bits, 0x00000040U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this_._internal_feature(), target);
  }

  // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_safety_category_thresholds_size());
         i < n; i++) {
      const auto& repfield = this_._internal_safety_category_thresholds().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              2, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // repeated string allowed_languages = 3;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    for (int i = 0, n = this_._internal_allowed_languages_size(); i < n; ++i) {
      const auto& s = this_._internal_allowed_languages().Get(i);
      target = stream->WriteString(3, s, target);
    }
  }

  // repeated .optimization_guide.proto.RequestSafetyCheck request_check = 4;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_request_check_size());
         i < n; i++) {
      const auto& repfield = this_._internal_request_check().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              4, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // optional .optimization_guide.proto.RawOutputCheck raw_output_check = 5;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        5, *this_._impl_.raw_output_check_, this_._impl_.raw_output_check_->GetCachedSize(), target,
        stream);
  }

  // repeated .optimization_guide.proto.ResponseSafetyCheck response_check = 6;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_response_check_size());
         i < n; i++) {
      const auto& repfield = this_._internal_response_check().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              6, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // optional bool only_cancel_unsafe_response_on_complete = 7;
  if (CheckHasBit(cached_has_bits, 0x00000080U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        7, this_._internal_only_cancel_unsafe_response_on_complete(), target);
  }

  // optional .optimization_guide.proto.PartialOutputChecks partial_output_checks = 8;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        8, *this_._impl_.partial_output_checks_, this_._impl_.partial_output_checks_->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:optimization_guide.proto.FeatureTextSafetyConfiguration)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t FeatureTextSafetyConfiguration::ByteSizeLong(const MessageLite& base) {
  const FeatureTextSafetyConfiguration& this_ = static_cast<const FeatureTextSafetyConfiguration&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t FeatureTextSafetyConfiguration::ByteSizeLong() const {
  const FeatureTextSafetyConfiguration& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:optimization_guide.proto.FeatureTextSafetyConfiguration)
  ::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>(0x00000080U & cached_has_bits) * 2;
  if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) {
    // repeated .optimization_guide.proto.SafetyCategoryThreshold safety_category_thresholds = 2;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_safety_category_thresholds_size();
      for (const auto& msg : this_._internal_safety_category_thresholds()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // repeated string allowed_languages = 3;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size +=
          1 * ::google::protobuf::internal::FromIntSize(this_._internal_allowed_languages().size());
      for (int i = 0, n = this_._internal_allowed_languages().size(); i < n; ++i) {
        total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
            this_._internal_allowed_languages().Get(i));
      }
    }
    // repeated .optimization_guide.proto.RequestSafetyCheck request_check = 4;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1UL * this_._internal_request_check_size();
      for (const auto& msg : this_._internal_request_check()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // repeated .optimization_guide.proto.ResponseSafetyCheck response_check = 6;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += 1UL * this_._internal_response_check_size();
      for (const auto& msg : this_._internal_response_check()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional .optimization_guide.proto.RawOutputCheck raw_output_check = 5;
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.raw_output_check_);
    }
    // optional .optimization_guide.proto.PartialOutputChecks partial_output_checks = 8;
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.partial_output_checks_);
    }
    // optional .optimization_guide.proto.ModelExecutionFeature feature = 1;
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_feature());
    }
  }
  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 FeatureTextSafetyConfiguration::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<FeatureTextSafetyConfiguration*>(&to_msg);
  auto& from = static_cast<const FeatureTextSafetyConfiguration&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:optimization_guide.proto.FeatureTextSafetyConfiguration)
  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->_internal_mutable_safety_category_thresholds()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_safety_category_thresholds());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_internal_mutable_allowed_languages()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_allowed_languages());
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_internal_mutable_request_check()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_request_check());
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_internal_mutable_response_check()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_response_check());
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      ABSL_DCHECK(from._impl_.raw_output_check_ != nullptr);
      if (_this->_impl_.raw_output_check_ == nullptr) {
        _this->_impl_.raw_output_check_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.raw_output_check_);
      } else {
        _this->_impl_.raw_output_check_->MergeFrom(*from._impl_.raw_output_check_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      ABSL_DCHECK(from._impl_.partial_output_checks_ != nullptr);
      if (_this->_impl_.partial_output_checks_ == nullptr) {
        _this->_impl_.partial_output_checks_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.partial_output_checks_);
      } else {
        _this->_impl_.partial_output_checks_->MergeFrom(*from._impl_.partial_output_checks_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      _this->_impl_.feature_ = from._impl_.feature_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      _this->_impl_.only_cancel_unsafe_response_on_complete_ = from._impl_.only_cancel_unsafe_response_on_complete_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void FeatureTextSafetyConfiguration::CopyFrom(const FeatureTextSafetyConfiguration& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:optimization_guide.proto.FeatureTextSafetyConfiguration)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void FeatureTextSafetyConfiguration::InternalSwap(FeatureTextSafetyConfiguration* 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_.safety_category_thresholds_.InternalSwap(&other->_impl_.safety_category_thresholds_);
  _impl_.allowed_languages_.InternalSwap(&other->_impl_.allowed_languages_);
  _impl_.request_check_.InternalSwap(&other->_impl_.request_check_);
  _impl_.response_check_.InternalSwap(&other->_impl_.response_check_);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.only_cancel_unsafe_response_on_complete_)
      + sizeof(FeatureTextSafetyConfiguration::_impl_.only_cancel_unsafe_response_on_complete_)
      - PROTOBUF_FIELD_OFFSET(FeatureTextSafetyConfiguration, _impl_.raw_output_check_)>(
          reinterpret_cast<char*>(&_impl_.raw_output_check_),
          reinterpret_cast<char*>(&other->_impl_.raw_output_check_));
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace proto
}  // namespace optimization_guide
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"