xref: /aosp_15_r20/out/soong/.intermediates/external/federated-compute/federated-compute-cc-proto-lite/android_arm64_armv8-2a_cortex-a55_static_apex33/gen/proto/fcp/protos/federatedcompute/secure_aggregations.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: fcp/protos/federatedcompute/secure_aggregations.proto

#include "fcp/protos/federatedcompute/secure_aggregations.pb.h"

#include <algorithm>
#include <cstdint>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = _pb::internal;

namespace google {
namespace internal {
namespace federatedcompute {
namespace v1 {
PROTOBUF_CONSTEXPR StartSecureAggregationRequest::StartSecureAggregationRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.aggregation_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.authorization_token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct StartSecureAggregationRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR StartSecureAggregationRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~StartSecureAggregationRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    StartSecureAggregationRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StartSecureAggregationRequestDefaultTypeInternal _StartSecureAggregationRequest_default_instance_;
PROTOBUF_CONSTEXPR StartSecureAggregationMetadata::StartSecureAggregationMetadata(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct StartSecureAggregationMetadataDefaultTypeInternal {
  PROTOBUF_CONSTEXPR StartSecureAggregationMetadataDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~StartSecureAggregationMetadataDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    StartSecureAggregationMetadata _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StartSecureAggregationMetadataDefaultTypeInternal _StartSecureAggregationMetadata_default_instance_;
PROTOBUF_CONSTEXPR StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse::StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse(
    ::_pbi::ConstantInitialized) {}
struct StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUseDefaultTypeInternal _StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse_default_instance_;
PROTOBUF_CONSTEXPR StartSecureAggregationResponse::StartSecureAggregationResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.secure_aggregands_)*/{}
  , /*decltype(_impl_.client_token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.secagg_protocol_forwarding_info_)*/nullptr
  , /*decltype(_impl_.protocol_execution_info_)*/nullptr
  , /*decltype(_impl_.masked_result_resource_)*/nullptr
  , /*decltype(_impl_.nonmasked_result_resource_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct StartSecureAggregationResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR StartSecureAggregationResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~StartSecureAggregationResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    StartSecureAggregationResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StartSecureAggregationResponseDefaultTypeInternal _StartSecureAggregationResponse_default_instance_;
PROTOBUF_CONSTEXPR SecureAggregandExecutionInfo::SecureAggregandExecutionInfo(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.modulus_)*/::uint64_t{0u}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct SecureAggregandExecutionInfoDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SecureAggregandExecutionInfoDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~SecureAggregandExecutionInfoDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    SecureAggregandExecutionInfo _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SecureAggregandExecutionInfoDefaultTypeInternal _SecureAggregandExecutionInfo_default_instance_;
PROTOBUF_CONSTEXPR SecureAggregationProtocolExecutionInfo::SecureAggregationProtocolExecutionInfo(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.expected_number_of_clients_)*/0
  , /*decltype(_impl_.minimum_surviving_clients_for_reconstruction_)*/0
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct SecureAggregationProtocolExecutionInfoDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SecureAggregationProtocolExecutionInfoDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~SecureAggregationProtocolExecutionInfoDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    SecureAggregationProtocolExecutionInfo _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SecureAggregationProtocolExecutionInfoDefaultTypeInternal _SecureAggregationProtocolExecutionInfo_default_instance_;
PROTOBUF_CONSTEXPR AbortSecureAggregationRequest::AbortSecureAggregationRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.aggregation_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.client_token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.status_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct AbortSecureAggregationRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR AbortSecureAggregationRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~AbortSecureAggregationRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    AbortSecureAggregationRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AbortSecureAggregationRequestDefaultTypeInternal _AbortSecureAggregationRequest_default_instance_;
PROTOBUF_CONSTEXPR AbortSecureAggregationResponse::AbortSecureAggregationResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct AbortSecureAggregationResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR AbortSecureAggregationResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~AbortSecureAggregationResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    AbortSecureAggregationResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AbortSecureAggregationResponseDefaultTypeInternal _AbortSecureAggregationResponse_default_instance_;
PROTOBUF_CONSTEXPR AdvertiseKeysRequest::AdvertiseKeysRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.aggregation_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.client_token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.advertise_keys_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct AdvertiseKeysRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR AdvertiseKeysRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~AdvertiseKeysRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    AdvertiseKeysRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AdvertiseKeysRequestDefaultTypeInternal _AdvertiseKeysRequest_default_instance_;
PROTOBUF_CONSTEXPR AdvertiseKeysMetadata::AdvertiseKeysMetadata(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.polling_interval_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct AdvertiseKeysMetadataDefaultTypeInternal {
  PROTOBUF_CONSTEXPR AdvertiseKeysMetadataDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~AdvertiseKeysMetadataDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    AdvertiseKeysMetadata _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AdvertiseKeysMetadataDefaultTypeInternal _AdvertiseKeysMetadata_default_instance_;
PROTOBUF_CONSTEXPR AdvertiseKeysResponse::AdvertiseKeysResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.share_keys_server_request_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct AdvertiseKeysResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR AdvertiseKeysResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~AdvertiseKeysResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    AdvertiseKeysResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AdvertiseKeysResponseDefaultTypeInternal _AdvertiseKeysResponse_default_instance_;
PROTOBUF_CONSTEXPR ShareKeysRequest::ShareKeysRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.aggregation_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.client_token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.share_keys_client_response_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct ShareKeysRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ShareKeysRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~ShareKeysRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    ShareKeysRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShareKeysRequestDefaultTypeInternal _ShareKeysRequest_default_instance_;
PROTOBUF_CONSTEXPR ShareKeysMetadata::ShareKeysMetadata(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.polling_interval_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct ShareKeysMetadataDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ShareKeysMetadataDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~ShareKeysMetadataDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    ShareKeysMetadata _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShareKeysMetadataDefaultTypeInternal _ShareKeysMetadata_default_instance_;
PROTOBUF_CONSTEXPR ShareKeysResponse::ShareKeysResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.masked_input_collection_server_request_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct ShareKeysResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ShareKeysResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~ShareKeysResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    ShareKeysResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShareKeysResponseDefaultTypeInternal _ShareKeysResponse_default_instance_;
PROTOBUF_CONSTEXPR SubmitSecureAggregationResultRequest::SubmitSecureAggregationResultRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.aggregation_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.client_token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.masked_result_resource_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.nonmasked_result_resource_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct SubmitSecureAggregationResultRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SubmitSecureAggregationResultRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~SubmitSecureAggregationResultRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    SubmitSecureAggregationResultRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubmitSecureAggregationResultRequestDefaultTypeInternal _SubmitSecureAggregationResultRequest_default_instance_;
PROTOBUF_CONSTEXPR SubmitSecureAggregationResultMetadata::SubmitSecureAggregationResultMetadata(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.polling_interval_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct SubmitSecureAggregationResultMetadataDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SubmitSecureAggregationResultMetadataDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~SubmitSecureAggregationResultMetadataDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    SubmitSecureAggregationResultMetadata _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubmitSecureAggregationResultMetadataDefaultTypeInternal _SubmitSecureAggregationResultMetadata_default_instance_;
PROTOBUF_CONSTEXPR SubmitSecureAggregationResultResponse::SubmitSecureAggregationResultResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.unmasking_server_request_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct SubmitSecureAggregationResultResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SubmitSecureAggregationResultResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~SubmitSecureAggregationResultResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    SubmitSecureAggregationResultResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubmitSecureAggregationResultResponseDefaultTypeInternal _SubmitSecureAggregationResultResponse_default_instance_;
PROTOBUF_CONSTEXPR UnmaskRequest::UnmaskRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.aggregation_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.client_token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.unmasking_client_response_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct UnmaskRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR UnmaskRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~UnmaskRequestDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    UnmaskRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UnmaskRequestDefaultTypeInternal _UnmaskRequest_default_instance_;
PROTOBUF_CONSTEXPR UnmaskResponse::UnmaskResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct UnmaskResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR UnmaskResponseDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~UnmaskResponseDefaultTypeInternal() {}
  union {  // NOLINT(misc-non-private-member-variables-in-classes)
    UnmaskResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UnmaskResponseDefaultTypeInternal _UnmaskResponse_default_instance_;
}  // namespace v1
}  // namespace federatedcompute
}  // namespace internal
}  // namespace google
namespace google {
namespace internal {
namespace federatedcompute {
namespace v1 {

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

class StartSecureAggregationRequest::_Internal {
 public:
};

StartSecureAggregationRequest::StartSecureAggregationRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.StartSecureAggregationRequest)
}
StartSecureAggregationRequest::StartSecureAggregationRequest(const StartSecureAggregationRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  StartSecureAggregationRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.authorization_token_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_aggregation_id().empty()) {
    _this->_impl_.aggregation_id_.Set(from._internal_aggregation_id(),
      _this->GetArenaForAllocation());
  }
  _impl_.authorization_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.authorization_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_authorization_token().empty()) {
    _this->_impl_.authorization_token_.Set(from._internal_authorization_token(),
      _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.StartSecureAggregationRequest)
}

inline void StartSecureAggregationRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.authorization_token_){}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.authorization_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.authorization_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

StartSecureAggregationRequest::~StartSecureAggregationRequest() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.StartSecureAggregationRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void StartSecureAggregationRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.aggregation_id_.Destroy();
  _impl_.authorization_token_.Destroy();
}

void StartSecureAggregationRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void StartSecureAggregationRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.StartSecureAggregationRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.aggregation_id_.ClearToEmpty();
  _impl_.authorization_token_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* StartSecureAggregationRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string aggregation_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_aggregation_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string authorization_token = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_authorization_token();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* StartSecureAggregationRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.StartSecureAggregationRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_aggregation_id().data(), static_cast<int>(this->_internal_aggregation_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.StartSecureAggregationRequest.aggregation_id");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_aggregation_id(), target);
  }

  // string authorization_token = 2;
  if (!this->_internal_authorization_token().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_authorization_token().data(), static_cast<int>(this->_internal_authorization_token().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.StartSecureAggregationRequest.authorization_token");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_authorization_token(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.StartSecureAggregationRequest)
  return target;
}

size_t StartSecureAggregationRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.StartSecureAggregationRequest)
  size_t total_size = 0;

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

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_aggregation_id());
  }

  // string authorization_token = 2;
  if (!this->_internal_authorization_token().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_authorization_token());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void StartSecureAggregationRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const StartSecureAggregationRequest*>(
      &from));
}

void StartSecureAggregationRequest::MergeFrom(const StartSecureAggregationRequest& from) {
  StartSecureAggregationRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.StartSecureAggregationRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_aggregation_id().empty()) {
    _this->_internal_set_aggregation_id(from._internal_aggregation_id());
  }
  if (!from._internal_authorization_token().empty()) {
    _this->_internal_set_authorization_token(from._internal_authorization_token());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void StartSecureAggregationRequest::CopyFrom(const StartSecureAggregationRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.StartSecureAggregationRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StartSecureAggregationRequest::IsInitialized() const {
  return true;
}

void StartSecureAggregationRequest::InternalSwap(StartSecureAggregationRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.aggregation_id_, lhs_arena,
      &other->_impl_.aggregation_id_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.authorization_token_, lhs_arena,
      &other->_impl_.authorization_token_, rhs_arena
  );
}

std::string StartSecureAggregationRequest::GetTypeName() const {
  return "google.internal.federatedcompute.v1.StartSecureAggregationRequest";
}


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

class StartSecureAggregationMetadata::_Internal {
 public:
};

StartSecureAggregationMetadata::StartSecureAggregationMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.StartSecureAggregationMetadata)
}
StartSecureAggregationMetadata::StartSecureAggregationMetadata(const StartSecureAggregationMetadata& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  StartSecureAggregationMetadata* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.StartSecureAggregationMetadata)
}

inline void StartSecureAggregationMetadata::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

StartSecureAggregationMetadata::~StartSecureAggregationMetadata() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.StartSecureAggregationMetadata)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void StartSecureAggregationMetadata::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void StartSecureAggregationMetadata::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void StartSecureAggregationMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.StartSecureAggregationMetadata)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* StartSecureAggregationMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* StartSecureAggregationMetadata::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.StartSecureAggregationMetadata)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.StartSecureAggregationMetadata)
  return target;
}

size_t StartSecureAggregationMetadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.StartSecureAggregationMetadata)
  size_t total_size = 0;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void StartSecureAggregationMetadata::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const StartSecureAggregationMetadata*>(
      &from));
}

void StartSecureAggregationMetadata::MergeFrom(const StartSecureAggregationMetadata& from) {
  StartSecureAggregationMetadata* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.StartSecureAggregationMetadata)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void StartSecureAggregationMetadata::CopyFrom(const StartSecureAggregationMetadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.StartSecureAggregationMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StartSecureAggregationMetadata::IsInitialized() const {
  return true;
}

void StartSecureAggregationMetadata::InternalSwap(StartSecureAggregationMetadata* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string StartSecureAggregationMetadata::GetTypeName() const {
  return "google.internal.federatedcompute.v1.StartSecureAggregationMetadata";
}


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

StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse::StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse() {}
StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse::StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse::MergeFrom(const StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse& other) {
  MergeFromInternal(other);
}

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

class StartSecureAggregationResponse::_Internal {
 public:
  static const ::google::internal::federatedcompute::v1::ForwardingInfo& secagg_protocol_forwarding_info(const StartSecureAggregationResponse* msg);
  static const ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo& protocol_execution_info(const StartSecureAggregationResponse* msg);
  static const ::google::internal::federatedcompute::v1::ByteStreamResource& masked_result_resource(const StartSecureAggregationResponse* msg);
  static const ::google::internal::federatedcompute::v1::ByteStreamResource& nonmasked_result_resource(const StartSecureAggregationResponse* msg);
};

const ::google::internal::federatedcompute::v1::ForwardingInfo&
StartSecureAggregationResponse::_Internal::secagg_protocol_forwarding_info(const StartSecureAggregationResponse* msg) {
  return *msg->_impl_.secagg_protocol_forwarding_info_;
}
const ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo&
StartSecureAggregationResponse::_Internal::protocol_execution_info(const StartSecureAggregationResponse* msg) {
  return *msg->_impl_.protocol_execution_info_;
}
const ::google::internal::federatedcompute::v1::ByteStreamResource&
StartSecureAggregationResponse::_Internal::masked_result_resource(const StartSecureAggregationResponse* msg) {
  return *msg->_impl_.masked_result_resource_;
}
const ::google::internal::federatedcompute::v1::ByteStreamResource&
StartSecureAggregationResponse::_Internal::nonmasked_result_resource(const StartSecureAggregationResponse* msg) {
  return *msg->_impl_.nonmasked_result_resource_;
}
void StartSecureAggregationResponse::clear_secagg_protocol_forwarding_info() {
  if (GetArenaForAllocation() == nullptr && _impl_.secagg_protocol_forwarding_info_ != nullptr) {
    delete _impl_.secagg_protocol_forwarding_info_;
  }
  _impl_.secagg_protocol_forwarding_info_ = nullptr;
}
void StartSecureAggregationResponse::clear_masked_result_resource() {
  if (GetArenaForAllocation() == nullptr && _impl_.masked_result_resource_ != nullptr) {
    delete _impl_.masked_result_resource_;
  }
  _impl_.masked_result_resource_ = nullptr;
}
void StartSecureAggregationResponse::clear_nonmasked_result_resource() {
  if (GetArenaForAllocation() == nullptr && _impl_.nonmasked_result_resource_ != nullptr) {
    delete _impl_.nonmasked_result_resource_;
  }
  _impl_.nonmasked_result_resource_ = nullptr;
}
StartSecureAggregationResponse::StartSecureAggregationResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.StartSecureAggregationResponse)
}
StartSecureAggregationResponse::StartSecureAggregationResponse(const StartSecureAggregationResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  StartSecureAggregationResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_.secure_aggregands_)*/{}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.secagg_protocol_forwarding_info_){nullptr}
    , decltype(_impl_.protocol_execution_info_){nullptr}
    , decltype(_impl_.masked_result_resource_){nullptr}
    , decltype(_impl_.nonmasked_result_resource_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _this->_impl_.secure_aggregands_.MergeFrom(from._impl_.secure_aggregands_);
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_client_token().empty()) {
    _this->_impl_.client_token_.Set(from._internal_client_token(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_secagg_protocol_forwarding_info()) {
    _this->_impl_.secagg_protocol_forwarding_info_ = new ::google::internal::federatedcompute::v1::ForwardingInfo(*from._impl_.secagg_protocol_forwarding_info_);
  }
  if (from._internal_has_protocol_execution_info()) {
    _this->_impl_.protocol_execution_info_ = new ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo(*from._impl_.protocol_execution_info_);
  }
  if (from._internal_has_masked_result_resource()) {
    _this->_impl_.masked_result_resource_ = new ::google::internal::federatedcompute::v1::ByteStreamResource(*from._impl_.masked_result_resource_);
  }
  if (from._internal_has_nonmasked_result_resource()) {
    _this->_impl_.nonmasked_result_resource_ = new ::google::internal::federatedcompute::v1::ByteStreamResource(*from._impl_.nonmasked_result_resource_);
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.StartSecureAggregationResponse)
}

inline void StartSecureAggregationResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_.secure_aggregands_)*/{::_pbi::ArenaInitialized(), arena}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.secagg_protocol_forwarding_info_){nullptr}
    , decltype(_impl_.protocol_execution_info_){nullptr}
    , decltype(_impl_.masked_result_resource_){nullptr}
    , decltype(_impl_.nonmasked_result_resource_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

StartSecureAggregationResponse::~StartSecureAggregationResponse() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.StartSecureAggregationResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void StartSecureAggregationResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.secure_aggregands_.Destruct();
  _impl_.secure_aggregands_.~MapFieldLite();
  _impl_.client_token_.Destroy();
  if (this != internal_default_instance()) delete _impl_.secagg_protocol_forwarding_info_;
  if (this != internal_default_instance()) delete _impl_.protocol_execution_info_;
  if (this != internal_default_instance()) delete _impl_.masked_result_resource_;
  if (this != internal_default_instance()) delete _impl_.nonmasked_result_resource_;
}

void StartSecureAggregationResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void StartSecureAggregationResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.StartSecureAggregationResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.secure_aggregands_.Clear();
  _impl_.client_token_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.secagg_protocol_forwarding_info_ != nullptr) {
    delete _impl_.secagg_protocol_forwarding_info_;
  }
  _impl_.secagg_protocol_forwarding_info_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.protocol_execution_info_ != nullptr) {
    delete _impl_.protocol_execution_info_;
  }
  _impl_.protocol_execution_info_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.masked_result_resource_ != nullptr) {
    delete _impl_.masked_result_resource_;
  }
  _impl_.masked_result_resource_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.nonmasked_result_resource_ != nullptr) {
    delete _impl_.nonmasked_result_resource_;
  }
  _impl_.nonmasked_result_resource_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* StartSecureAggregationResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .google.internal.federatedcompute.v1.ForwardingInfo secagg_protocol_forwarding_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_secagg_protocol_forwarding_info(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // map<string, .google.internal.federatedcompute.v1.SecureAggregandExecutionInfo> secure_aggregands = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&_impl_.secure_aggregands_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo protocol_execution_info = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_protocol_execution_info(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.internal.federatedcompute.v1.ByteStreamResource masked_result_resource = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_masked_result_resource(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.internal.federatedcompute.v1.ByteStreamResource nonmasked_result_resource = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_nonmasked_result_resource(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string client_token = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          auto str = _internal_mutable_client_token();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* StartSecureAggregationResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.StartSecureAggregationResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .google.internal.federatedcompute.v1.ForwardingInfo secagg_protocol_forwarding_info = 1;
  if (this->_internal_has_secagg_protocol_forwarding_info()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::secagg_protocol_forwarding_info(this),
        _Internal::secagg_protocol_forwarding_info(this).GetCachedSize(), target, stream);
  }

  // map<string, .google.internal.federatedcompute.v1.SecureAggregandExecutionInfo> secure_aggregands = 2;
  if (!this->_internal_secure_aggregands().empty()) {
    using MapType = ::_pb::Map<std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo>;
    using WireHelper = StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse::Funcs;
    const auto& map_field = this->_internal_secure_aggregands();
    auto check_utf8 = [](const MapType::value_type& entry) {
      (void)entry;
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        entry.first.data(), static_cast<int>(entry.first.length()),
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
        "google.internal.federatedcompute.v1.StartSecureAggregationResponse.SecureAggregandsEntry.key");
    };

    if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
      for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
        target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream);
        check_utf8(entry);
      }
    } else {
      for (const auto& entry : map_field) {
        target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream);
        check_utf8(entry);
      }
    }
  }

  // .google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo protocol_execution_info = 3;
  if (this->_internal_has_protocol_execution_info()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::protocol_execution_info(this),
        _Internal::protocol_execution_info(this).GetCachedSize(), target, stream);
  }

  // .google.internal.federatedcompute.v1.ByteStreamResource masked_result_resource = 4;
  if (this->_internal_has_masked_result_resource()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::masked_result_resource(this),
        _Internal::masked_result_resource(this).GetCachedSize(), target, stream);
  }

  // .google.internal.federatedcompute.v1.ByteStreamResource nonmasked_result_resource = 5;
  if (this->_internal_has_nonmasked_result_resource()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::nonmasked_result_resource(this),
        _Internal::nonmasked_result_resource(this).GetCachedSize(), target, stream);
  }

  // string client_token = 6;
  if (!this->_internal_client_token().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_client_token().data(), static_cast<int>(this->_internal_client_token().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.StartSecureAggregationResponse.client_token");
    target = stream->WriteStringMaybeAliased(
        6, this->_internal_client_token(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.StartSecureAggregationResponse)
  return target;
}

size_t StartSecureAggregationResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.StartSecureAggregationResponse)
  size_t total_size = 0;

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

  // map<string, .google.internal.federatedcompute.v1.SecureAggregandExecutionInfo> secure_aggregands = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_secure_aggregands_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo >::const_iterator
      it = this->_internal_secure_aggregands().begin();
      it != this->_internal_secure_aggregands().end(); ++it) {
    total_size += StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // string client_token = 6;
  if (!this->_internal_client_token().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_client_token());
  }

  // .google.internal.federatedcompute.v1.ForwardingInfo secagg_protocol_forwarding_info = 1;
  if (this->_internal_has_secagg_protocol_forwarding_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.secagg_protocol_forwarding_info_);
  }

  // .google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo protocol_execution_info = 3;
  if (this->_internal_has_protocol_execution_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.protocol_execution_info_);
  }

  // .google.internal.federatedcompute.v1.ByteStreamResource masked_result_resource = 4;
  if (this->_internal_has_masked_result_resource()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.masked_result_resource_);
  }

  // .google.internal.federatedcompute.v1.ByteStreamResource nonmasked_result_resource = 5;
  if (this->_internal_has_nonmasked_result_resource()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.nonmasked_result_resource_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void StartSecureAggregationResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const StartSecureAggregationResponse*>(
      &from));
}

void StartSecureAggregationResponse::MergeFrom(const StartSecureAggregationResponse& from) {
  StartSecureAggregationResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.StartSecureAggregationResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.secure_aggregands_.MergeFrom(from._impl_.secure_aggregands_);
  if (!from._internal_client_token().empty()) {
    _this->_internal_set_client_token(from._internal_client_token());
  }
  if (from._internal_has_secagg_protocol_forwarding_info()) {
    _this->_internal_mutable_secagg_protocol_forwarding_info()->::google::internal::federatedcompute::v1::ForwardingInfo::MergeFrom(
        from._internal_secagg_protocol_forwarding_info());
  }
  if (from._internal_has_protocol_execution_info()) {
    _this->_internal_mutable_protocol_execution_info()->::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo::MergeFrom(
        from._internal_protocol_execution_info());
  }
  if (from._internal_has_masked_result_resource()) {
    _this->_internal_mutable_masked_result_resource()->::google::internal::federatedcompute::v1::ByteStreamResource::MergeFrom(
        from._internal_masked_result_resource());
  }
  if (from._internal_has_nonmasked_result_resource()) {
    _this->_internal_mutable_nonmasked_result_resource()->::google::internal::federatedcompute::v1::ByteStreamResource::MergeFrom(
        from._internal_nonmasked_result_resource());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void StartSecureAggregationResponse::CopyFrom(const StartSecureAggregationResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.StartSecureAggregationResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StartSecureAggregationResponse::IsInitialized() const {
  return true;
}

void StartSecureAggregationResponse::InternalSwap(StartSecureAggregationResponse* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.secure_aggregands_.InternalSwap(&other->_impl_.secure_aggregands_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.client_token_, lhs_arena,
      &other->_impl_.client_token_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(StartSecureAggregationResponse, _impl_.nonmasked_result_resource_)
      + sizeof(StartSecureAggregationResponse::_impl_.nonmasked_result_resource_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(StartSecureAggregationResponse, _impl_.secagg_protocol_forwarding_info_)>(
          reinterpret_cast<char*>(&_impl_.secagg_protocol_forwarding_info_),
          reinterpret_cast<char*>(&other->_impl_.secagg_protocol_forwarding_info_));
}

std::string StartSecureAggregationResponse::GetTypeName() const {
  return "google.internal.federatedcompute.v1.StartSecureAggregationResponse";
}


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

class SecureAggregandExecutionInfo::_Internal {
 public:
};

SecureAggregandExecutionInfo::SecureAggregandExecutionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo)
}
SecureAggregandExecutionInfo::SecureAggregandExecutionInfo(const SecureAggregandExecutionInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SecureAggregandExecutionInfo* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.modulus_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _this->_impl_.modulus_ = from._impl_.modulus_;
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo)
}

inline void SecureAggregandExecutionInfo::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.modulus_){::uint64_t{0u}}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

SecureAggregandExecutionInfo::~SecureAggregandExecutionInfo() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void SecureAggregandExecutionInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void SecureAggregandExecutionInfo::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void SecureAggregandExecutionInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.modulus_ = ::uint64_t{0u};
  _internal_metadata_.Clear<std::string>();
}

const char* SecureAggregandExecutionInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // uint64 modulus = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.modulus_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* SecureAggregandExecutionInfo::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // uint64 modulus = 1;
  if (this->_internal_modulus() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_modulus(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo)
  return target;
}

size_t SecureAggregandExecutionInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo)
  size_t total_size = 0;

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

  // uint64 modulus = 1;
  if (this->_internal_modulus() != 0) {
    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_modulus());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SecureAggregandExecutionInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SecureAggregandExecutionInfo*>(
      &from));
}

void SecureAggregandExecutionInfo::MergeFrom(const SecureAggregandExecutionInfo& from) {
  SecureAggregandExecutionInfo* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_modulus() != 0) {
    _this->_internal_set_modulus(from._internal_modulus());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SecureAggregandExecutionInfo::CopyFrom(const SecureAggregandExecutionInfo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SecureAggregandExecutionInfo::IsInitialized() const {
  return true;
}

void SecureAggregandExecutionInfo::InternalSwap(SecureAggregandExecutionInfo* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.modulus_, other->_impl_.modulus_);
}

std::string SecureAggregandExecutionInfo::GetTypeName() const {
  return "google.internal.federatedcompute.v1.SecureAggregandExecutionInfo";
}


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

class SecureAggregationProtocolExecutionInfo::_Internal {
 public:
};

SecureAggregationProtocolExecutionInfo::SecureAggregationProtocolExecutionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo)
}
SecureAggregationProtocolExecutionInfo::SecureAggregationProtocolExecutionInfo(const SecureAggregationProtocolExecutionInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SecureAggregationProtocolExecutionInfo* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.expected_number_of_clients_){}
    , decltype(_impl_.minimum_surviving_clients_for_reconstruction_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&_impl_.expected_number_of_clients_, &from._impl_.expected_number_of_clients_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.minimum_surviving_clients_for_reconstruction_) -
    reinterpret_cast<char*>(&_impl_.expected_number_of_clients_)) + sizeof(_impl_.minimum_surviving_clients_for_reconstruction_));
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo)
}

inline void SecureAggregationProtocolExecutionInfo::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.expected_number_of_clients_){0}
    , decltype(_impl_.minimum_surviving_clients_for_reconstruction_){0}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

SecureAggregationProtocolExecutionInfo::~SecureAggregationProtocolExecutionInfo() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void SecureAggregationProtocolExecutionInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void SecureAggregationProtocolExecutionInfo::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void SecureAggregationProtocolExecutionInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&_impl_.expected_number_of_clients_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&_impl_.minimum_surviving_clients_for_reconstruction_) -
      reinterpret_cast<char*>(&_impl_.expected_number_of_clients_)) + sizeof(_impl_.minimum_surviving_clients_for_reconstruction_));
  _internal_metadata_.Clear<std::string>();
}

const char* SecureAggregationProtocolExecutionInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 expected_number_of_clients = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.expected_number_of_clients_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 minimum_surviving_clients_for_reconstruction = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.minimum_surviving_clients_for_reconstruction_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* SecureAggregationProtocolExecutionInfo::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 expected_number_of_clients = 1;
  if (this->_internal_expected_number_of_clients() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_expected_number_of_clients(), target);
  }

  // int32 minimum_surviving_clients_for_reconstruction = 2;
  if (this->_internal_minimum_surviving_clients_for_reconstruction() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_minimum_surviving_clients_for_reconstruction(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo)
  return target;
}

size_t SecureAggregationProtocolExecutionInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo)
  size_t total_size = 0;

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

  // int32 expected_number_of_clients = 1;
  if (this->_internal_expected_number_of_clients() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_expected_number_of_clients());
  }

  // int32 minimum_surviving_clients_for_reconstruction = 2;
  if (this->_internal_minimum_surviving_clients_for_reconstruction() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_minimum_surviving_clients_for_reconstruction());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SecureAggregationProtocolExecutionInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SecureAggregationProtocolExecutionInfo*>(
      &from));
}

void SecureAggregationProtocolExecutionInfo::MergeFrom(const SecureAggregationProtocolExecutionInfo& from) {
  SecureAggregationProtocolExecutionInfo* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_expected_number_of_clients() != 0) {
    _this->_internal_set_expected_number_of_clients(from._internal_expected_number_of_clients());
  }
  if (from._internal_minimum_surviving_clients_for_reconstruction() != 0) {
    _this->_internal_set_minimum_surviving_clients_for_reconstruction(from._internal_minimum_surviving_clients_for_reconstruction());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SecureAggregationProtocolExecutionInfo::CopyFrom(const SecureAggregationProtocolExecutionInfo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SecureAggregationProtocolExecutionInfo::IsInitialized() const {
  return true;
}

void SecureAggregationProtocolExecutionInfo::InternalSwap(SecureAggregationProtocolExecutionInfo* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SecureAggregationProtocolExecutionInfo, _impl_.minimum_surviving_clients_for_reconstruction_)
      + sizeof(SecureAggregationProtocolExecutionInfo::_impl_.minimum_surviving_clients_for_reconstruction_)  // NOLINT
      - PROTOBUF_FIELD_OFFSET(SecureAggregationProtocolExecutionInfo, _impl_.expected_number_of_clients_)>(
          reinterpret_cast<char*>(&_impl_.expected_number_of_clients_),
          reinterpret_cast<char*>(&other->_impl_.expected_number_of_clients_));
}

std::string SecureAggregationProtocolExecutionInfo::GetTypeName() const {
  return "google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo";
}


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

class AbortSecureAggregationRequest::_Internal {
 public:
  static const ::google::internal::federatedcompute::v1::Status& status(const AbortSecureAggregationRequest* msg);
};

const ::google::internal::federatedcompute::v1::Status&
AbortSecureAggregationRequest::_Internal::status(const AbortSecureAggregationRequest* msg) {
  return *msg->_impl_.status_;
}
void AbortSecureAggregationRequest::clear_status() {
  if (GetArenaForAllocation() == nullptr && _impl_.status_ != nullptr) {
    delete _impl_.status_;
  }
  _impl_.status_ = nullptr;
}
AbortSecureAggregationRequest::AbortSecureAggregationRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.AbortSecureAggregationRequest)
}
AbortSecureAggregationRequest::AbortSecureAggregationRequest(const AbortSecureAggregationRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  AbortSecureAggregationRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.status_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_aggregation_id().empty()) {
    _this->_impl_.aggregation_id_.Set(from._internal_aggregation_id(),
      _this->GetArenaForAllocation());
  }
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_client_token().empty()) {
    _this->_impl_.client_token_.Set(from._internal_client_token(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_status()) {
    _this->_impl_.status_ = new ::google::internal::federatedcompute::v1::Status(*from._impl_.status_);
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.AbortSecureAggregationRequest)
}

inline void AbortSecureAggregationRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.status_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

AbortSecureAggregationRequest::~AbortSecureAggregationRequest() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.AbortSecureAggregationRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void AbortSecureAggregationRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.aggregation_id_.Destroy();
  _impl_.client_token_.Destroy();
  if (this != internal_default_instance()) delete _impl_.status_;
}

void AbortSecureAggregationRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void AbortSecureAggregationRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.AbortSecureAggregationRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.aggregation_id_.ClearToEmpty();
  _impl_.client_token_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.status_ != nullptr) {
    delete _impl_.status_;
  }
  _impl_.status_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* AbortSecureAggregationRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string aggregation_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_aggregation_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string client_token = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_client_token();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.internal.federatedcompute.v1.Status status = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_status(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* AbortSecureAggregationRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.AbortSecureAggregationRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_aggregation_id().data(), static_cast<int>(this->_internal_aggregation_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.AbortSecureAggregationRequest.aggregation_id");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_aggregation_id(), target);
  }

  // string client_token = 2;
  if (!this->_internal_client_token().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_client_token().data(), static_cast<int>(this->_internal_client_token().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.AbortSecureAggregationRequest.client_token");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_client_token(), target);
  }

  // .google.internal.federatedcompute.v1.Status status = 3;
  if (this->_internal_has_status()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::status(this),
        _Internal::status(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.AbortSecureAggregationRequest)
  return target;
}

size_t AbortSecureAggregationRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.AbortSecureAggregationRequest)
  size_t total_size = 0;

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

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_aggregation_id());
  }

  // string client_token = 2;
  if (!this->_internal_client_token().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_client_token());
  }

  // .google.internal.federatedcompute.v1.Status status = 3;
  if (this->_internal_has_status()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.status_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AbortSecureAggregationRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const AbortSecureAggregationRequest*>(
      &from));
}

void AbortSecureAggregationRequest::MergeFrom(const AbortSecureAggregationRequest& from) {
  AbortSecureAggregationRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.AbortSecureAggregationRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_aggregation_id().empty()) {
    _this->_internal_set_aggregation_id(from._internal_aggregation_id());
  }
  if (!from._internal_client_token().empty()) {
    _this->_internal_set_client_token(from._internal_client_token());
  }
  if (from._internal_has_status()) {
    _this->_internal_mutable_status()->::google::internal::federatedcompute::v1::Status::MergeFrom(
        from._internal_status());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void AbortSecureAggregationRequest::CopyFrom(const AbortSecureAggregationRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.AbortSecureAggregationRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AbortSecureAggregationRequest::IsInitialized() const {
  return true;
}

void AbortSecureAggregationRequest::InternalSwap(AbortSecureAggregationRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.aggregation_id_, lhs_arena,
      &other->_impl_.aggregation_id_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.client_token_, lhs_arena,
      &other->_impl_.client_token_, rhs_arena
  );
  swap(_impl_.status_, other->_impl_.status_);
}

std::string AbortSecureAggregationRequest::GetTypeName() const {
  return "google.internal.federatedcompute.v1.AbortSecureAggregationRequest";
}


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

class AbortSecureAggregationResponse::_Internal {
 public:
};

AbortSecureAggregationResponse::AbortSecureAggregationResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.AbortSecureAggregationResponse)
}
AbortSecureAggregationResponse::AbortSecureAggregationResponse(const AbortSecureAggregationResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  AbortSecureAggregationResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.AbortSecureAggregationResponse)
}

inline void AbortSecureAggregationResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

AbortSecureAggregationResponse::~AbortSecureAggregationResponse() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.AbortSecureAggregationResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void AbortSecureAggregationResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void AbortSecureAggregationResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void AbortSecureAggregationResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.AbortSecureAggregationResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* AbortSecureAggregationResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* AbortSecureAggregationResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.AbortSecureAggregationResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.AbortSecureAggregationResponse)
  return target;
}

size_t AbortSecureAggregationResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.AbortSecureAggregationResponse)
  size_t total_size = 0;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AbortSecureAggregationResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const AbortSecureAggregationResponse*>(
      &from));
}

void AbortSecureAggregationResponse::MergeFrom(const AbortSecureAggregationResponse& from) {
  AbortSecureAggregationResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.AbortSecureAggregationResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void AbortSecureAggregationResponse::CopyFrom(const AbortSecureAggregationResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.AbortSecureAggregationResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AbortSecureAggregationResponse::IsInitialized() const {
  return true;
}

void AbortSecureAggregationResponse::InternalSwap(AbortSecureAggregationResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string AbortSecureAggregationResponse::GetTypeName() const {
  return "google.internal.federatedcompute.v1.AbortSecureAggregationResponse";
}


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

class AdvertiseKeysRequest::_Internal {
 public:
  static const ::fcp::secagg::AdvertiseKeys& advertise_keys(const AdvertiseKeysRequest* msg);
};

const ::fcp::secagg::AdvertiseKeys&
AdvertiseKeysRequest::_Internal::advertise_keys(const AdvertiseKeysRequest* msg) {
  return *msg->_impl_.advertise_keys_;
}
void AdvertiseKeysRequest::clear_advertise_keys() {
  if (GetArenaForAllocation() == nullptr && _impl_.advertise_keys_ != nullptr) {
    delete _impl_.advertise_keys_;
  }
  _impl_.advertise_keys_ = nullptr;
}
AdvertiseKeysRequest::AdvertiseKeysRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.AdvertiseKeysRequest)
}
AdvertiseKeysRequest::AdvertiseKeysRequest(const AdvertiseKeysRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  AdvertiseKeysRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.advertise_keys_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_aggregation_id().empty()) {
    _this->_impl_.aggregation_id_.Set(from._internal_aggregation_id(),
      _this->GetArenaForAllocation());
  }
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_client_token().empty()) {
    _this->_impl_.client_token_.Set(from._internal_client_token(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_advertise_keys()) {
    _this->_impl_.advertise_keys_ = new ::fcp::secagg::AdvertiseKeys(*from._impl_.advertise_keys_);
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.AdvertiseKeysRequest)
}

inline void AdvertiseKeysRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.advertise_keys_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

AdvertiseKeysRequest::~AdvertiseKeysRequest() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.AdvertiseKeysRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void AdvertiseKeysRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.aggregation_id_.Destroy();
  _impl_.client_token_.Destroy();
  if (this != internal_default_instance()) delete _impl_.advertise_keys_;
}

void AdvertiseKeysRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void AdvertiseKeysRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.AdvertiseKeysRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.aggregation_id_.ClearToEmpty();
  _impl_.client_token_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.advertise_keys_ != nullptr) {
    delete _impl_.advertise_keys_;
  }
  _impl_.advertise_keys_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* AdvertiseKeysRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string aggregation_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_aggregation_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string client_token = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_client_token();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .fcp.secagg.AdvertiseKeys advertise_keys = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_advertise_keys(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* AdvertiseKeysRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.AdvertiseKeysRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_aggregation_id().data(), static_cast<int>(this->_internal_aggregation_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.AdvertiseKeysRequest.aggregation_id");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_aggregation_id(), target);
  }

  // string client_token = 2;
  if (!this->_internal_client_token().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_client_token().data(), static_cast<int>(this->_internal_client_token().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.AdvertiseKeysRequest.client_token");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_client_token(), target);
  }

  // .fcp.secagg.AdvertiseKeys advertise_keys = 3;
  if (this->_internal_has_advertise_keys()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::advertise_keys(this),
        _Internal::advertise_keys(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.AdvertiseKeysRequest)
  return target;
}

size_t AdvertiseKeysRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.AdvertiseKeysRequest)
  size_t total_size = 0;

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

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_aggregation_id());
  }

  // string client_token = 2;
  if (!this->_internal_client_token().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_client_token());
  }

  // .fcp.secagg.AdvertiseKeys advertise_keys = 3;
  if (this->_internal_has_advertise_keys()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.advertise_keys_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AdvertiseKeysRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const AdvertiseKeysRequest*>(
      &from));
}

void AdvertiseKeysRequest::MergeFrom(const AdvertiseKeysRequest& from) {
  AdvertiseKeysRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.AdvertiseKeysRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_aggregation_id().empty()) {
    _this->_internal_set_aggregation_id(from._internal_aggregation_id());
  }
  if (!from._internal_client_token().empty()) {
    _this->_internal_set_client_token(from._internal_client_token());
  }
  if (from._internal_has_advertise_keys()) {
    _this->_internal_mutable_advertise_keys()->::fcp::secagg::AdvertiseKeys::MergeFrom(
        from._internal_advertise_keys());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void AdvertiseKeysRequest::CopyFrom(const AdvertiseKeysRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.AdvertiseKeysRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AdvertiseKeysRequest::IsInitialized() const {
  return true;
}

void AdvertiseKeysRequest::InternalSwap(AdvertiseKeysRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.aggregation_id_, lhs_arena,
      &other->_impl_.aggregation_id_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.client_token_, lhs_arena,
      &other->_impl_.client_token_, rhs_arena
  );
  swap(_impl_.advertise_keys_, other->_impl_.advertise_keys_);
}

std::string AdvertiseKeysRequest::GetTypeName() const {
  return "google.internal.federatedcompute.v1.AdvertiseKeysRequest";
}


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

class AdvertiseKeysMetadata::_Internal {
 public:
  static const ::PROTOBUF_NAMESPACE_ID::Duration& polling_interval(const AdvertiseKeysMetadata* msg);
};

const ::PROTOBUF_NAMESPACE_ID::Duration&
AdvertiseKeysMetadata::_Internal::polling_interval(const AdvertiseKeysMetadata* msg) {
  return *msg->_impl_.polling_interval_;
}
void AdvertiseKeysMetadata::clear_polling_interval() {
  if (GetArenaForAllocation() == nullptr && _impl_.polling_interval_ != nullptr) {
    delete _impl_.polling_interval_;
  }
  _impl_.polling_interval_ = nullptr;
}
AdvertiseKeysMetadata::AdvertiseKeysMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.AdvertiseKeysMetadata)
}
AdvertiseKeysMetadata::AdvertiseKeysMetadata(const AdvertiseKeysMetadata& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  AdvertiseKeysMetadata* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.polling_interval_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_polling_interval()) {
    _this->_impl_.polling_interval_ = new ::PROTOBUF_NAMESPACE_ID::Duration(*from._impl_.polling_interval_);
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.AdvertiseKeysMetadata)
}

inline void AdvertiseKeysMetadata::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.polling_interval_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

AdvertiseKeysMetadata::~AdvertiseKeysMetadata() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.AdvertiseKeysMetadata)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void AdvertiseKeysMetadata::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.polling_interval_;
}

void AdvertiseKeysMetadata::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void AdvertiseKeysMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.AdvertiseKeysMetadata)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.polling_interval_ != nullptr) {
    delete _impl_.polling_interval_;
  }
  _impl_.polling_interval_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* AdvertiseKeysMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .google.protobuf.Duration polling_interval = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_polling_interval(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* AdvertiseKeysMetadata::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.AdvertiseKeysMetadata)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .google.protobuf.Duration polling_interval = 1;
  if (this->_internal_has_polling_interval()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::polling_interval(this),
        _Internal::polling_interval(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.AdvertiseKeysMetadata)
  return target;
}

size_t AdvertiseKeysMetadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.AdvertiseKeysMetadata)
  size_t total_size = 0;

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

  // .google.protobuf.Duration polling_interval = 1;
  if (this->_internal_has_polling_interval()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.polling_interval_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AdvertiseKeysMetadata::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const AdvertiseKeysMetadata*>(
      &from));
}

void AdvertiseKeysMetadata::MergeFrom(const AdvertiseKeysMetadata& from) {
  AdvertiseKeysMetadata* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.AdvertiseKeysMetadata)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_polling_interval()) {
    _this->_internal_mutable_polling_interval()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(
        from._internal_polling_interval());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void AdvertiseKeysMetadata::CopyFrom(const AdvertiseKeysMetadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.AdvertiseKeysMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AdvertiseKeysMetadata::IsInitialized() const {
  return true;
}

void AdvertiseKeysMetadata::InternalSwap(AdvertiseKeysMetadata* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.polling_interval_, other->_impl_.polling_interval_);
}

std::string AdvertiseKeysMetadata::GetTypeName() const {
  return "google.internal.federatedcompute.v1.AdvertiseKeysMetadata";
}


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

class AdvertiseKeysResponse::_Internal {
 public:
  static const ::fcp::secagg::ShareKeysRequest& share_keys_server_request(const AdvertiseKeysResponse* msg);
};

const ::fcp::secagg::ShareKeysRequest&
AdvertiseKeysResponse::_Internal::share_keys_server_request(const AdvertiseKeysResponse* msg) {
  return *msg->_impl_.share_keys_server_request_;
}
void AdvertiseKeysResponse::clear_share_keys_server_request() {
  if (GetArenaForAllocation() == nullptr && _impl_.share_keys_server_request_ != nullptr) {
    delete _impl_.share_keys_server_request_;
  }
  _impl_.share_keys_server_request_ = nullptr;
}
AdvertiseKeysResponse::AdvertiseKeysResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.AdvertiseKeysResponse)
}
AdvertiseKeysResponse::AdvertiseKeysResponse(const AdvertiseKeysResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  AdvertiseKeysResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.share_keys_server_request_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_share_keys_server_request()) {
    _this->_impl_.share_keys_server_request_ = new ::fcp::secagg::ShareKeysRequest(*from._impl_.share_keys_server_request_);
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.AdvertiseKeysResponse)
}

inline void AdvertiseKeysResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.share_keys_server_request_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

AdvertiseKeysResponse::~AdvertiseKeysResponse() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.AdvertiseKeysResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void AdvertiseKeysResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.share_keys_server_request_;
}

void AdvertiseKeysResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void AdvertiseKeysResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.AdvertiseKeysResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.share_keys_server_request_ != nullptr) {
    delete _impl_.share_keys_server_request_;
  }
  _impl_.share_keys_server_request_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* AdvertiseKeysResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .fcp.secagg.ShareKeysRequest share_keys_server_request = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_share_keys_server_request(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* AdvertiseKeysResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.AdvertiseKeysResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .fcp.secagg.ShareKeysRequest share_keys_server_request = 1;
  if (this->_internal_has_share_keys_server_request()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::share_keys_server_request(this),
        _Internal::share_keys_server_request(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.AdvertiseKeysResponse)
  return target;
}

size_t AdvertiseKeysResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.AdvertiseKeysResponse)
  size_t total_size = 0;

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

  // .fcp.secagg.ShareKeysRequest share_keys_server_request = 1;
  if (this->_internal_has_share_keys_server_request()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.share_keys_server_request_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AdvertiseKeysResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const AdvertiseKeysResponse*>(
      &from));
}

void AdvertiseKeysResponse::MergeFrom(const AdvertiseKeysResponse& from) {
  AdvertiseKeysResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.AdvertiseKeysResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_share_keys_server_request()) {
    _this->_internal_mutable_share_keys_server_request()->::fcp::secagg::ShareKeysRequest::MergeFrom(
        from._internal_share_keys_server_request());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void AdvertiseKeysResponse::CopyFrom(const AdvertiseKeysResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.AdvertiseKeysResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AdvertiseKeysResponse::IsInitialized() const {
  return true;
}

void AdvertiseKeysResponse::InternalSwap(AdvertiseKeysResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.share_keys_server_request_, other->_impl_.share_keys_server_request_);
}

std::string AdvertiseKeysResponse::GetTypeName() const {
  return "google.internal.federatedcompute.v1.AdvertiseKeysResponse";
}


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

class ShareKeysRequest::_Internal {
 public:
  static const ::fcp::secagg::ShareKeysResponse& share_keys_client_response(const ShareKeysRequest* msg);
};

const ::fcp::secagg::ShareKeysResponse&
ShareKeysRequest::_Internal::share_keys_client_response(const ShareKeysRequest* msg) {
  return *msg->_impl_.share_keys_client_response_;
}
void ShareKeysRequest::clear_share_keys_client_response() {
  if (GetArenaForAllocation() == nullptr && _impl_.share_keys_client_response_ != nullptr) {
    delete _impl_.share_keys_client_response_;
  }
  _impl_.share_keys_client_response_ = nullptr;
}
ShareKeysRequest::ShareKeysRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.ShareKeysRequest)
}
ShareKeysRequest::ShareKeysRequest(const ShareKeysRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  ShareKeysRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.share_keys_client_response_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_aggregation_id().empty()) {
    _this->_impl_.aggregation_id_.Set(from._internal_aggregation_id(),
      _this->GetArenaForAllocation());
  }
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_client_token().empty()) {
    _this->_impl_.client_token_.Set(from._internal_client_token(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_share_keys_client_response()) {
    _this->_impl_.share_keys_client_response_ = new ::fcp::secagg::ShareKeysResponse(*from._impl_.share_keys_client_response_);
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.ShareKeysRequest)
}

inline void ShareKeysRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.share_keys_client_response_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

ShareKeysRequest::~ShareKeysRequest() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.ShareKeysRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void ShareKeysRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.aggregation_id_.Destroy();
  _impl_.client_token_.Destroy();
  if (this != internal_default_instance()) delete _impl_.share_keys_client_response_;
}

void ShareKeysRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void ShareKeysRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.ShareKeysRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.aggregation_id_.ClearToEmpty();
  _impl_.client_token_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.share_keys_client_response_ != nullptr) {
    delete _impl_.share_keys_client_response_;
  }
  _impl_.share_keys_client_response_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* ShareKeysRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string aggregation_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_aggregation_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string client_token = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_client_token();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .fcp.secagg.ShareKeysResponse share_keys_client_response = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_share_keys_client_response(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* ShareKeysRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.ShareKeysRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_aggregation_id().data(), static_cast<int>(this->_internal_aggregation_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.ShareKeysRequest.aggregation_id");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_aggregation_id(), target);
  }

  // string client_token = 2;
  if (!this->_internal_client_token().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_client_token().data(), static_cast<int>(this->_internal_client_token().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.ShareKeysRequest.client_token");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_client_token(), target);
  }

  // .fcp.secagg.ShareKeysResponse share_keys_client_response = 3;
  if (this->_internal_has_share_keys_client_response()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::share_keys_client_response(this),
        _Internal::share_keys_client_response(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.ShareKeysRequest)
  return target;
}

size_t ShareKeysRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.ShareKeysRequest)
  size_t total_size = 0;

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

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_aggregation_id());
  }

  // string client_token = 2;
  if (!this->_internal_client_token().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_client_token());
  }

  // .fcp.secagg.ShareKeysResponse share_keys_client_response = 3;
  if (this->_internal_has_share_keys_client_response()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.share_keys_client_response_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ShareKeysRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const ShareKeysRequest*>(
      &from));
}

void ShareKeysRequest::MergeFrom(const ShareKeysRequest& from) {
  ShareKeysRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.ShareKeysRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_aggregation_id().empty()) {
    _this->_internal_set_aggregation_id(from._internal_aggregation_id());
  }
  if (!from._internal_client_token().empty()) {
    _this->_internal_set_client_token(from._internal_client_token());
  }
  if (from._internal_has_share_keys_client_response()) {
    _this->_internal_mutable_share_keys_client_response()->::fcp::secagg::ShareKeysResponse::MergeFrom(
        from._internal_share_keys_client_response());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void ShareKeysRequest::CopyFrom(const ShareKeysRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.ShareKeysRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ShareKeysRequest::IsInitialized() const {
  return true;
}

void ShareKeysRequest::InternalSwap(ShareKeysRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.aggregation_id_, lhs_arena,
      &other->_impl_.aggregation_id_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.client_token_, lhs_arena,
      &other->_impl_.client_token_, rhs_arena
  );
  swap(_impl_.share_keys_client_response_, other->_impl_.share_keys_client_response_);
}

std::string ShareKeysRequest::GetTypeName() const {
  return "google.internal.federatedcompute.v1.ShareKeysRequest";
}


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

class ShareKeysMetadata::_Internal {
 public:
  static const ::PROTOBUF_NAMESPACE_ID::Duration& polling_interval(const ShareKeysMetadata* msg);
};

const ::PROTOBUF_NAMESPACE_ID::Duration&
ShareKeysMetadata::_Internal::polling_interval(const ShareKeysMetadata* msg) {
  return *msg->_impl_.polling_interval_;
}
void ShareKeysMetadata::clear_polling_interval() {
  if (GetArenaForAllocation() == nullptr && _impl_.polling_interval_ != nullptr) {
    delete _impl_.polling_interval_;
  }
  _impl_.polling_interval_ = nullptr;
}
ShareKeysMetadata::ShareKeysMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.ShareKeysMetadata)
}
ShareKeysMetadata::ShareKeysMetadata(const ShareKeysMetadata& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  ShareKeysMetadata* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.polling_interval_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_polling_interval()) {
    _this->_impl_.polling_interval_ = new ::PROTOBUF_NAMESPACE_ID::Duration(*from._impl_.polling_interval_);
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.ShareKeysMetadata)
}

inline void ShareKeysMetadata::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.polling_interval_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

ShareKeysMetadata::~ShareKeysMetadata() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.ShareKeysMetadata)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void ShareKeysMetadata::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.polling_interval_;
}

void ShareKeysMetadata::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void ShareKeysMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.ShareKeysMetadata)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.polling_interval_ != nullptr) {
    delete _impl_.polling_interval_;
  }
  _impl_.polling_interval_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* ShareKeysMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .google.protobuf.Duration polling_interval = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_polling_interval(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* ShareKeysMetadata::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.ShareKeysMetadata)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .google.protobuf.Duration polling_interval = 1;
  if (this->_internal_has_polling_interval()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::polling_interval(this),
        _Internal::polling_interval(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.ShareKeysMetadata)
  return target;
}

size_t ShareKeysMetadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.ShareKeysMetadata)
  size_t total_size = 0;

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

  // .google.protobuf.Duration polling_interval = 1;
  if (this->_internal_has_polling_interval()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.polling_interval_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ShareKeysMetadata::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const ShareKeysMetadata*>(
      &from));
}

void ShareKeysMetadata::MergeFrom(const ShareKeysMetadata& from) {
  ShareKeysMetadata* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.ShareKeysMetadata)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_polling_interval()) {
    _this->_internal_mutable_polling_interval()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(
        from._internal_polling_interval());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void ShareKeysMetadata::CopyFrom(const ShareKeysMetadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.ShareKeysMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ShareKeysMetadata::IsInitialized() const {
  return true;
}

void ShareKeysMetadata::InternalSwap(ShareKeysMetadata* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.polling_interval_, other->_impl_.polling_interval_);
}

std::string ShareKeysMetadata::GetTypeName() const {
  return "google.internal.federatedcompute.v1.ShareKeysMetadata";
}


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

class ShareKeysResponse::_Internal {
 public:
  static const ::fcp::secagg::MaskedInputCollectionRequest& masked_input_collection_server_request(const ShareKeysResponse* msg);
};

const ::fcp::secagg::MaskedInputCollectionRequest&
ShareKeysResponse::_Internal::masked_input_collection_server_request(const ShareKeysResponse* msg) {
  return *msg->_impl_.masked_input_collection_server_request_;
}
void ShareKeysResponse::clear_masked_input_collection_server_request() {
  if (GetArenaForAllocation() == nullptr && _impl_.masked_input_collection_server_request_ != nullptr) {
    delete _impl_.masked_input_collection_server_request_;
  }
  _impl_.masked_input_collection_server_request_ = nullptr;
}
ShareKeysResponse::ShareKeysResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.ShareKeysResponse)
}
ShareKeysResponse::ShareKeysResponse(const ShareKeysResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  ShareKeysResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.masked_input_collection_server_request_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_masked_input_collection_server_request()) {
    _this->_impl_.masked_input_collection_server_request_ = new ::fcp::secagg::MaskedInputCollectionRequest(*from._impl_.masked_input_collection_server_request_);
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.ShareKeysResponse)
}

inline void ShareKeysResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.masked_input_collection_server_request_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

ShareKeysResponse::~ShareKeysResponse() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.ShareKeysResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void ShareKeysResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.masked_input_collection_server_request_;
}

void ShareKeysResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void ShareKeysResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.ShareKeysResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.masked_input_collection_server_request_ != nullptr) {
    delete _impl_.masked_input_collection_server_request_;
  }
  _impl_.masked_input_collection_server_request_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* ShareKeysResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .fcp.secagg.MaskedInputCollectionRequest masked_input_collection_server_request = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_masked_input_collection_server_request(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* ShareKeysResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.ShareKeysResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .fcp.secagg.MaskedInputCollectionRequest masked_input_collection_server_request = 1;
  if (this->_internal_has_masked_input_collection_server_request()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::masked_input_collection_server_request(this),
        _Internal::masked_input_collection_server_request(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.ShareKeysResponse)
  return target;
}

size_t ShareKeysResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.ShareKeysResponse)
  size_t total_size = 0;

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

  // .fcp.secagg.MaskedInputCollectionRequest masked_input_collection_server_request = 1;
  if (this->_internal_has_masked_input_collection_server_request()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.masked_input_collection_server_request_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ShareKeysResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const ShareKeysResponse*>(
      &from));
}

void ShareKeysResponse::MergeFrom(const ShareKeysResponse& from) {
  ShareKeysResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.ShareKeysResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_masked_input_collection_server_request()) {
    _this->_internal_mutable_masked_input_collection_server_request()->::fcp::secagg::MaskedInputCollectionRequest::MergeFrom(
        from._internal_masked_input_collection_server_request());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void ShareKeysResponse::CopyFrom(const ShareKeysResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.ShareKeysResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ShareKeysResponse::IsInitialized() const {
  return true;
}

void ShareKeysResponse::InternalSwap(ShareKeysResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.masked_input_collection_server_request_, other->_impl_.masked_input_collection_server_request_);
}

std::string ShareKeysResponse::GetTypeName() const {
  return "google.internal.federatedcompute.v1.ShareKeysResponse";
}


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

class SubmitSecureAggregationResultRequest::_Internal {
 public:
};

SubmitSecureAggregationResultRequest::SubmitSecureAggregationResultRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest)
}
SubmitSecureAggregationResultRequest::SubmitSecureAggregationResultRequest(const SubmitSecureAggregationResultRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SubmitSecureAggregationResultRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.masked_result_resource_name_){}
    , decltype(_impl_.nonmasked_result_resource_name_){}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_aggregation_id().empty()) {
    _this->_impl_.aggregation_id_.Set(from._internal_aggregation_id(),
      _this->GetArenaForAllocation());
  }
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_client_token().empty()) {
    _this->_impl_.client_token_.Set(from._internal_client_token(),
      _this->GetArenaForAllocation());
  }
  _impl_.masked_result_resource_name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.masked_result_resource_name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_masked_result_resource_name().empty()) {
    _this->_impl_.masked_result_resource_name_.Set(from._internal_masked_result_resource_name(),
      _this->GetArenaForAllocation());
  }
  _impl_.nonmasked_result_resource_name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.nonmasked_result_resource_name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_nonmasked_result_resource_name().empty()) {
    _this->_impl_.nonmasked_result_resource_name_.Set(from._internal_nonmasked_result_resource_name(),
      _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest)
}

inline void SubmitSecureAggregationResultRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.masked_result_resource_name_){}
    , decltype(_impl_.nonmasked_result_resource_name_){}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.masked_result_resource_name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.masked_result_resource_name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.nonmasked_result_resource_name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.nonmasked_result_resource_name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

SubmitSecureAggregationResultRequest::~SubmitSecureAggregationResultRequest() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void SubmitSecureAggregationResultRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.aggregation_id_.Destroy();
  _impl_.client_token_.Destroy();
  _impl_.masked_result_resource_name_.Destroy();
  _impl_.nonmasked_result_resource_name_.Destroy();
}

void SubmitSecureAggregationResultRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void SubmitSecureAggregationResultRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.aggregation_id_.ClearToEmpty();
  _impl_.client_token_.ClearToEmpty();
  _impl_.masked_result_resource_name_.ClearToEmpty();
  _impl_.nonmasked_result_resource_name_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* SubmitSecureAggregationResultRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string aggregation_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_aggregation_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string client_token = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_client_token();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string masked_result_resource_name = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_masked_result_resource_name();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string nonmasked_result_resource_name = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          auto str = _internal_mutable_nonmasked_result_resource_name();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* SubmitSecureAggregationResultRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_aggregation_id().data(), static_cast<int>(this->_internal_aggregation_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.aggregation_id");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_aggregation_id(), target);
  }

  // string client_token = 2;
  if (!this->_internal_client_token().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_client_token().data(), static_cast<int>(this->_internal_client_token().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.client_token");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_client_token(), target);
  }

  // string masked_result_resource_name = 3;
  if (!this->_internal_masked_result_resource_name().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_masked_result_resource_name().data(), static_cast<int>(this->_internal_masked_result_resource_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.masked_result_resource_name");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_masked_result_resource_name(), target);
  }

  // string nonmasked_result_resource_name = 4;
  if (!this->_internal_nonmasked_result_resource_name().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_nonmasked_result_resource_name().data(), static_cast<int>(this->_internal_nonmasked_result_resource_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.nonmasked_result_resource_name");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_nonmasked_result_resource_name(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest)
  return target;
}

size_t SubmitSecureAggregationResultRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest)
  size_t total_size = 0;

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

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_aggregation_id());
  }

  // string client_token = 2;
  if (!this->_internal_client_token().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_client_token());
  }

  // string masked_result_resource_name = 3;
  if (!this->_internal_masked_result_resource_name().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_masked_result_resource_name());
  }

  // string nonmasked_result_resource_name = 4;
  if (!this->_internal_nonmasked_result_resource_name().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_nonmasked_result_resource_name());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SubmitSecureAggregationResultRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SubmitSecureAggregationResultRequest*>(
      &from));
}

void SubmitSecureAggregationResultRequest::MergeFrom(const SubmitSecureAggregationResultRequest& from) {
  SubmitSecureAggregationResultRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_aggregation_id().empty()) {
    _this->_internal_set_aggregation_id(from._internal_aggregation_id());
  }
  if (!from._internal_client_token().empty()) {
    _this->_internal_set_client_token(from._internal_client_token());
  }
  if (!from._internal_masked_result_resource_name().empty()) {
    _this->_internal_set_masked_result_resource_name(from._internal_masked_result_resource_name());
  }
  if (!from._internal_nonmasked_result_resource_name().empty()) {
    _this->_internal_set_nonmasked_result_resource_name(from._internal_nonmasked_result_resource_name());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SubmitSecureAggregationResultRequest::CopyFrom(const SubmitSecureAggregationResultRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SubmitSecureAggregationResultRequest::IsInitialized() const {
  return true;
}

void SubmitSecureAggregationResultRequest::InternalSwap(SubmitSecureAggregationResultRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.aggregation_id_, lhs_arena,
      &other->_impl_.aggregation_id_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.client_token_, lhs_arena,
      &other->_impl_.client_token_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.masked_result_resource_name_, lhs_arena,
      &other->_impl_.masked_result_resource_name_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.nonmasked_result_resource_name_, lhs_arena,
      &other->_impl_.nonmasked_result_resource_name_, rhs_arena
  );
}

std::string SubmitSecureAggregationResultRequest::GetTypeName() const {
  return "google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest";
}


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

class SubmitSecureAggregationResultMetadata::_Internal {
 public:
  static const ::PROTOBUF_NAMESPACE_ID::Duration& polling_interval(const SubmitSecureAggregationResultMetadata* msg);
};

const ::PROTOBUF_NAMESPACE_ID::Duration&
SubmitSecureAggregationResultMetadata::_Internal::polling_interval(const SubmitSecureAggregationResultMetadata* msg) {
  return *msg->_impl_.polling_interval_;
}
void SubmitSecureAggregationResultMetadata::clear_polling_interval() {
  if (GetArenaForAllocation() == nullptr && _impl_.polling_interval_ != nullptr) {
    delete _impl_.polling_interval_;
  }
  _impl_.polling_interval_ = nullptr;
}
SubmitSecureAggregationResultMetadata::SubmitSecureAggregationResultMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata)
}
SubmitSecureAggregationResultMetadata::SubmitSecureAggregationResultMetadata(const SubmitSecureAggregationResultMetadata& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SubmitSecureAggregationResultMetadata* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.polling_interval_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_polling_interval()) {
    _this->_impl_.polling_interval_ = new ::PROTOBUF_NAMESPACE_ID::Duration(*from._impl_.polling_interval_);
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata)
}

inline void SubmitSecureAggregationResultMetadata::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.polling_interval_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

SubmitSecureAggregationResultMetadata::~SubmitSecureAggregationResultMetadata() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void SubmitSecureAggregationResultMetadata::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.polling_interval_;
}

void SubmitSecureAggregationResultMetadata::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void SubmitSecureAggregationResultMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.polling_interval_ != nullptr) {
    delete _impl_.polling_interval_;
  }
  _impl_.polling_interval_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* SubmitSecureAggregationResultMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .google.protobuf.Duration polling_interval = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_polling_interval(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* SubmitSecureAggregationResultMetadata::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .google.protobuf.Duration polling_interval = 1;
  if (this->_internal_has_polling_interval()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::polling_interval(this),
        _Internal::polling_interval(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata)
  return target;
}

size_t SubmitSecureAggregationResultMetadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata)
  size_t total_size = 0;

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

  // .google.protobuf.Duration polling_interval = 1;
  if (this->_internal_has_polling_interval()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.polling_interval_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SubmitSecureAggregationResultMetadata::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SubmitSecureAggregationResultMetadata*>(
      &from));
}

void SubmitSecureAggregationResultMetadata::MergeFrom(const SubmitSecureAggregationResultMetadata& from) {
  SubmitSecureAggregationResultMetadata* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_polling_interval()) {
    _this->_internal_mutable_polling_interval()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(
        from._internal_polling_interval());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SubmitSecureAggregationResultMetadata::CopyFrom(const SubmitSecureAggregationResultMetadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SubmitSecureAggregationResultMetadata::IsInitialized() const {
  return true;
}

void SubmitSecureAggregationResultMetadata::InternalSwap(SubmitSecureAggregationResultMetadata* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.polling_interval_, other->_impl_.polling_interval_);
}

std::string SubmitSecureAggregationResultMetadata::GetTypeName() const {
  return "google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata";
}


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

class SubmitSecureAggregationResultResponse::_Internal {
 public:
  static const ::fcp::secagg::UnmaskingRequest& unmasking_server_request(const SubmitSecureAggregationResultResponse* msg);
};

const ::fcp::secagg::UnmaskingRequest&
SubmitSecureAggregationResultResponse::_Internal::unmasking_server_request(const SubmitSecureAggregationResultResponse* msg) {
  return *msg->_impl_.unmasking_server_request_;
}
void SubmitSecureAggregationResultResponse::clear_unmasking_server_request() {
  if (GetArenaForAllocation() == nullptr && _impl_.unmasking_server_request_ != nullptr) {
    delete _impl_.unmasking_server_request_;
  }
  _impl_.unmasking_server_request_ = nullptr;
}
SubmitSecureAggregationResultResponse::SubmitSecureAggregationResultResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse)
}
SubmitSecureAggregationResultResponse::SubmitSecureAggregationResultResponse(const SubmitSecureAggregationResultResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SubmitSecureAggregationResultResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.unmasking_server_request_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_unmasking_server_request()) {
    _this->_impl_.unmasking_server_request_ = new ::fcp::secagg::UnmaskingRequest(*from._impl_.unmasking_server_request_);
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse)
}

inline void SubmitSecureAggregationResultResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.unmasking_server_request_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

SubmitSecureAggregationResultResponse::~SubmitSecureAggregationResultResponse() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void SubmitSecureAggregationResultResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.unmasking_server_request_;
}

void SubmitSecureAggregationResultResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void SubmitSecureAggregationResultResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.unmasking_server_request_ != nullptr) {
    delete _impl_.unmasking_server_request_;
  }
  _impl_.unmasking_server_request_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* SubmitSecureAggregationResultResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .fcp.secagg.UnmaskingRequest unmasking_server_request = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_unmasking_server_request(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* SubmitSecureAggregationResultResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .fcp.secagg.UnmaskingRequest unmasking_server_request = 1;
  if (this->_internal_has_unmasking_server_request()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::unmasking_server_request(this),
        _Internal::unmasking_server_request(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse)
  return target;
}

size_t SubmitSecureAggregationResultResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse)
  size_t total_size = 0;

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

  // .fcp.secagg.UnmaskingRequest unmasking_server_request = 1;
  if (this->_internal_has_unmasking_server_request()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.unmasking_server_request_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SubmitSecureAggregationResultResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SubmitSecureAggregationResultResponse*>(
      &from));
}

void SubmitSecureAggregationResultResponse::MergeFrom(const SubmitSecureAggregationResultResponse& from) {
  SubmitSecureAggregationResultResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_unmasking_server_request()) {
    _this->_internal_mutable_unmasking_server_request()->::fcp::secagg::UnmaskingRequest::MergeFrom(
        from._internal_unmasking_server_request());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SubmitSecureAggregationResultResponse::CopyFrom(const SubmitSecureAggregationResultResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SubmitSecureAggregationResultResponse::IsInitialized() const {
  return true;
}

void SubmitSecureAggregationResultResponse::InternalSwap(SubmitSecureAggregationResultResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.unmasking_server_request_, other->_impl_.unmasking_server_request_);
}

std::string SubmitSecureAggregationResultResponse::GetTypeName() const {
  return "google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse";
}


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

class UnmaskRequest::_Internal {
 public:
  static const ::fcp::secagg::UnmaskingResponse& unmasking_client_response(const UnmaskRequest* msg);
};

const ::fcp::secagg::UnmaskingResponse&
UnmaskRequest::_Internal::unmasking_client_response(const UnmaskRequest* msg) {
  return *msg->_impl_.unmasking_client_response_;
}
void UnmaskRequest::clear_unmasking_client_response() {
  if (GetArenaForAllocation() == nullptr && _impl_.unmasking_client_response_ != nullptr) {
    delete _impl_.unmasking_client_response_;
  }
  _impl_.unmasking_client_response_ = nullptr;
}
UnmaskRequest::UnmaskRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.UnmaskRequest)
}
UnmaskRequest::UnmaskRequest(const UnmaskRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  UnmaskRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.unmasking_client_response_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_aggregation_id().empty()) {
    _this->_impl_.aggregation_id_.Set(from._internal_aggregation_id(),
      _this->GetArenaForAllocation());
  }
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_client_token().empty()) {
    _this->_impl_.client_token_.Set(from._internal_client_token(),
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_unmasking_client_response()) {
    _this->_impl_.unmasking_client_response_ = new ::fcp::secagg::UnmaskingResponse(*from._impl_.unmasking_client_response_);
  }
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.UnmaskRequest)
}

inline void UnmaskRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_.aggregation_id_){}
    , decltype(_impl_.client_token_){}
    , decltype(_impl_.unmasking_client_response_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.aggregation_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.aggregation_id_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.client_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.client_token_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

UnmaskRequest::~UnmaskRequest() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.UnmaskRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void UnmaskRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.aggregation_id_.Destroy();
  _impl_.client_token_.Destroy();
  if (this != internal_default_instance()) delete _impl_.unmasking_client_response_;
}

void UnmaskRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void UnmaskRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.UnmaskRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.aggregation_id_.ClearToEmpty();
  _impl_.client_token_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && _impl_.unmasking_client_response_ != nullptr) {
    delete _impl_.unmasking_client_response_;
  }
  _impl_.unmasking_client_response_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* UnmaskRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string aggregation_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_aggregation_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string client_token = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_client_token();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .fcp.secagg.UnmaskingResponse unmasking_client_response = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_unmasking_client_response(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* UnmaskRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.UnmaskRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_aggregation_id().data(), static_cast<int>(this->_internal_aggregation_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.UnmaskRequest.aggregation_id");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_aggregation_id(), target);
  }

  // string client_token = 2;
  if (!this->_internal_client_token().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_client_token().data(), static_cast<int>(this->_internal_client_token().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "google.internal.federatedcompute.v1.UnmaskRequest.client_token");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_client_token(), target);
  }

  // .fcp.secagg.UnmaskingResponse unmasking_client_response = 3;
  if (this->_internal_has_unmasking_client_response()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::unmasking_client_response(this),
        _Internal::unmasking_client_response(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.UnmaskRequest)
  return target;
}

size_t UnmaskRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.UnmaskRequest)
  size_t total_size = 0;

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

  // string aggregation_id = 1;
  if (!this->_internal_aggregation_id().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_aggregation_id());
  }

  // string client_token = 2;
  if (!this->_internal_client_token().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_client_token());
  }

  // .fcp.secagg.UnmaskingResponse unmasking_client_response = 3;
  if (this->_internal_has_unmasking_client_response()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.unmasking_client_response_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void UnmaskRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const UnmaskRequest*>(
      &from));
}

void UnmaskRequest::MergeFrom(const UnmaskRequest& from) {
  UnmaskRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.UnmaskRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_aggregation_id().empty()) {
    _this->_internal_set_aggregation_id(from._internal_aggregation_id());
  }
  if (!from._internal_client_token().empty()) {
    _this->_internal_set_client_token(from._internal_client_token());
  }
  if (from._internal_has_unmasking_client_response()) {
    _this->_internal_mutable_unmasking_client_response()->::fcp::secagg::UnmaskingResponse::MergeFrom(
        from._internal_unmasking_client_response());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void UnmaskRequest::CopyFrom(const UnmaskRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.UnmaskRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UnmaskRequest::IsInitialized() const {
  return true;
}

void UnmaskRequest::InternalSwap(UnmaskRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.aggregation_id_, lhs_arena,
      &other->_impl_.aggregation_id_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.client_token_, lhs_arena,
      &other->_impl_.client_token_, rhs_arena
  );
  swap(_impl_.unmasking_client_response_, other->_impl_.unmasking_client_response_);
}

std::string UnmaskRequest::GetTypeName() const {
  return "google.internal.federatedcompute.v1.UnmaskRequest";
}


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

class UnmaskResponse::_Internal {
 public:
};

UnmaskResponse::UnmaskResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.UnmaskResponse)
}
UnmaskResponse::UnmaskResponse(const UnmaskResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  UnmaskResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.UnmaskResponse)
}

inline void UnmaskResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

UnmaskResponse::~UnmaskResponse() {
  // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.UnmaskResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void UnmaskResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void UnmaskResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void UnmaskResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.UnmaskResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* UnmaskResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* UnmaskResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.UnmaskResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.UnmaskResponse)
  return target;
}

size_t UnmaskResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.UnmaskResponse)
  size_t total_size = 0;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void UnmaskResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const UnmaskResponse*>(
      &from));
}

void UnmaskResponse::MergeFrom(const UnmaskResponse& from) {
  UnmaskResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.UnmaskResponse)
  GOOGLE_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void UnmaskResponse::CopyFrom(const UnmaskResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.UnmaskResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UnmaskResponse::IsInitialized() const {
  return true;
}

void UnmaskResponse::InternalSwap(UnmaskResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string UnmaskResponse::GetTypeName() const {
  return "google.internal.federatedcompute.v1.UnmaskResponse";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace federatedcompute
}  // namespace internal
}  // namespace google
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::StartSecureAggregationRequest*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::StartSecureAggregationRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::StartSecureAggregationRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::StartSecureAggregationMetadata*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::StartSecureAggregationMetadata >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::StartSecureAggregationMetadata >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::StartSecureAggregationResponse*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::StartSecureAggregationResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::StartSecureAggregationResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::AbortSecureAggregationRequest*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::AbortSecureAggregationRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::AbortSecureAggregationRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::AbortSecureAggregationResponse*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::AbortSecureAggregationResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::AbortSecureAggregationResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::AdvertiseKeysRequest*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::AdvertiseKeysRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::AdvertiseKeysRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::AdvertiseKeysMetadata*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::AdvertiseKeysMetadata >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::AdvertiseKeysMetadata >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::AdvertiseKeysResponse*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::AdvertiseKeysResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::AdvertiseKeysResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::ShareKeysRequest*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::ShareKeysRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::ShareKeysRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::ShareKeysMetadata*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::ShareKeysMetadata >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::ShareKeysMetadata >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::ShareKeysResponse*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::ShareKeysResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::ShareKeysResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultRequest*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultMetadata*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultMetadata >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultMetadata >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultResponse*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::UnmaskRequest*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::UnmaskRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::UnmaskRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::UnmaskResponse*
Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::UnmaskResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::UnmaskResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>