chroot/var/cache/portage/chromeos-base/libbrillo/out/Default/gen/include/bindings/private_membership_rlwe.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: private_membership_rlwe.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_private_5fmembership_5frlwe_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_private_5fmembership_5frlwe_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3011000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3011004 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
#include "private_membership.pb.h"
#include "serialization.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_private_5fmembership_5frlwe_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[18]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
namespace private_membership {
namespace rlwe {
class EncryptedBucket;
class EncryptedBucketDefaultTypeInternal;
extern EncryptedBucketDefaultTypeInternal _EncryptedBucket_default_instance_;
class EncryptedBucket_EncryptedIdValuePair;
class EncryptedBucket_EncryptedIdValuePairDefaultTypeInternal;
extern EncryptedBucket_EncryptedIdValuePairDefaultTypeInternal _EncryptedBucket_EncryptedIdValuePair_default_instance_;
class EncryptedBucketsParameters;
class EncryptedBucketsParametersDefaultTypeInternal;
extern EncryptedBucketsParametersDefaultTypeInternal _EncryptedBucketsParameters_default_instance_;
class HashedBucketsParameters;
class HashedBucketsParametersDefaultTypeInternal;
extern HashedBucketsParametersDefaultTypeInternal _HashedBucketsParameters_default_instance_;
class PirRequest;
class PirRequestDefaultTypeInternal;
extern PirRequestDefaultTypeInternal _PirRequest_default_instance_;
class PirResponse;
class PirResponseDefaultTypeInternal;
extern PirResponseDefaultTypeInternal _PirResponse_default_instance_;
class PrivateMembershipRlweOprfRequest;
class PrivateMembershipRlweOprfRequestDefaultTypeInternal;
extern PrivateMembershipRlweOprfRequestDefaultTypeInternal _PrivateMembershipRlweOprfRequest_default_instance_;
class PrivateMembershipRlweOprfResponse;
class PrivateMembershipRlweOprfResponseDefaultTypeInternal;
extern PrivateMembershipRlweOprfResponseDefaultTypeInternal _PrivateMembershipRlweOprfResponse_default_instance_;
class PrivateMembershipRlwePirResponse;
class PrivateMembershipRlwePirResponseDefaultTypeInternal;
extern PrivateMembershipRlwePirResponseDefaultTypeInternal _PrivateMembershipRlwePirResponse_default_instance_;
class PrivateMembershipRlweQuery;
class PrivateMembershipRlweQueryDefaultTypeInternal;
extern PrivateMembershipRlweQueryDefaultTypeInternal _PrivateMembershipRlweQuery_default_instance_;
class PrivateMembershipRlweQueryRequest;
class PrivateMembershipRlweQueryRequestDefaultTypeInternal;
extern PrivateMembershipRlweQueryRequestDefaultTypeInternal _PrivateMembershipRlweQueryRequest_default_instance_;
class PrivateMembershipRlweQueryResponse;
class PrivateMembershipRlweQueryResponseDefaultTypeInternal;
extern PrivateMembershipRlweQueryResponseDefaultTypeInternal _PrivateMembershipRlweQueryResponse_default_instance_;
class PrivateMembershipRlweQuery_HashedBucketId;
class PrivateMembershipRlweQuery_HashedBucketIdDefaultTypeInternal;
extern PrivateMembershipRlweQuery_HashedBucketIdDefaultTypeInternal _PrivateMembershipRlweQuery_HashedBucketId_default_instance_;
class RlweMembershipResponses;
class RlweMembershipResponsesDefaultTypeInternal;
extern RlweMembershipResponsesDefaultTypeInternal _RlweMembershipResponses_default_instance_;
class RlweMembershipResponses_MembershipResponseEntry;
class RlweMembershipResponses_MembershipResponseEntryDefaultTypeInternal;
extern RlweMembershipResponses_MembershipResponseEntryDefaultTypeInternal _RlweMembershipResponses_MembershipResponseEntry_default_instance_;
class RlweParameters;
class RlweParametersDefaultTypeInternal;
extern RlweParametersDefaultTypeInternal _RlweParameters_default_instance_;
class RlwePlaintextId;
class RlwePlaintextIdDefaultTypeInternal;
extern RlwePlaintextIdDefaultTypeInternal _RlwePlaintextId_default_instance_;
class Uint128;
class Uint128DefaultTypeInternal;
extern Uint128DefaultTypeInternal _Uint128_default_instance_;
}  // namespace rlwe
}  // namespace private_membership
PROTOBUF_NAMESPACE_OPEN
template<> ::private_membership::rlwe::EncryptedBucket* Arena::CreateMaybeMessage<::private_membership::rlwe::EncryptedBucket>(Arena*);
template<> ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair* Arena::CreateMaybeMessage<::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair>(Arena*);
template<> ::private_membership::rlwe::EncryptedBucketsParameters* Arena::CreateMaybeMessage<::private_membership::rlwe::EncryptedBucketsParameters>(Arena*);
template<> ::private_membership::rlwe::HashedBucketsParameters* Arena::CreateMaybeMessage<::private_membership::rlwe::HashedBucketsParameters>(Arena*);
template<> ::private_membership::rlwe::PirRequest* Arena::CreateMaybeMessage<::private_membership::rlwe::PirRequest>(Arena*);
template<> ::private_membership::rlwe::PirResponse* Arena::CreateMaybeMessage<::private_membership::rlwe::PirResponse>(Arena*);
template<> ::private_membership::rlwe::PrivateMembershipRlweOprfRequest* Arena::CreateMaybeMessage<::private_membership::rlwe::PrivateMembershipRlweOprfRequest>(Arena*);
template<> ::private_membership::rlwe::PrivateMembershipRlweOprfResponse* Arena::CreateMaybeMessage<::private_membership::rlwe::PrivateMembershipRlweOprfResponse>(Arena*);
template<> ::private_membership::rlwe::PrivateMembershipRlwePirResponse* Arena::CreateMaybeMessage<::private_membership::rlwe::PrivateMembershipRlwePirResponse>(Arena*);
template<> ::private_membership::rlwe::PrivateMembershipRlweQuery* Arena::CreateMaybeMessage<::private_membership::rlwe::PrivateMembershipRlweQuery>(Arena*);
template<> ::private_membership::rlwe::PrivateMembershipRlweQueryRequest* Arena::CreateMaybeMessage<::private_membership::rlwe::PrivateMembershipRlweQueryRequest>(Arena*);
template<> ::private_membership::rlwe::PrivateMembershipRlweQueryResponse* Arena::CreateMaybeMessage<::private_membership::rlwe::PrivateMembershipRlweQueryResponse>(Arena*);
template<> ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* Arena::CreateMaybeMessage<::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId>(Arena*);
template<> ::private_membership::rlwe::RlweMembershipResponses* Arena::CreateMaybeMessage<::private_membership::rlwe::RlweMembershipResponses>(Arena*);
template<> ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry* Arena::CreateMaybeMessage<::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry>(Arena*);
template<> ::private_membership::rlwe::RlweParameters* Arena::CreateMaybeMessage<::private_membership::rlwe::RlweParameters>(Arena*);
template<> ::private_membership::rlwe::RlwePlaintextId* Arena::CreateMaybeMessage<::private_membership::rlwe::RlwePlaintextId>(Arena*);
template<> ::private_membership::rlwe::Uint128* Arena::CreateMaybeMessage<::private_membership::rlwe::Uint128>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace private_membership {
namespace rlwe {

enum RlweUseCase : int {
  RLWE_USE_CASE_UNDEFINED = 0,
  TEST_USE_CASE = 1,
  TEST_USE_CASE2 = 2,
  TEST_USE_CASE3 = 3,
  CROS_DEVICE_STATE = 5,
  CROS_DEVICE_SECONDARY_STATE = 12,
  CROS_FRESNEL_DAILY = 13,
  CROS_FRESNEL_MONTHLY = 14,
  CROS_FRESNEL_ALL_TIME = 15,
  RlweUseCase_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  RlweUseCase_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool RlweUseCase_IsValid(int value);
constexpr RlweUseCase RlweUseCase_MIN = RLWE_USE_CASE_UNDEFINED;
constexpr RlweUseCase RlweUseCase_MAX = CROS_FRESNEL_ALL_TIME;
constexpr int RlweUseCase_ARRAYSIZE = RlweUseCase_MAX + 1;

const std::string& RlweUseCase_Name(RlweUseCase value);
template<typename T>
inline const std::string& RlweUseCase_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RlweUseCase>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RlweUseCase_Name.");
  return RlweUseCase_Name(static_cast<RlweUseCase>(enum_t_value));
}
bool RlweUseCase_Parse(
    const std::string& name, RlweUseCase* value);
// ===================================================================

class PrivateMembershipRlweOprfRequest :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.PrivateMembershipRlweOprfRequest) */ {
 public:
  PrivateMembershipRlweOprfRequest();
  virtual ~PrivateMembershipRlweOprfRequest();

  PrivateMembershipRlweOprfRequest(const PrivateMembershipRlweOprfRequest& from);
  PrivateMembershipRlweOprfRequest(PrivateMembershipRlweOprfRequest&& from) noexcept
    : PrivateMembershipRlweOprfRequest() {
    *this = ::std::move(from);
  }

  inline PrivateMembershipRlweOprfRequest& operator=(const PrivateMembershipRlweOprfRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrivateMembershipRlweOprfRequest& operator=(PrivateMembershipRlweOprfRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const PrivateMembershipRlweOprfRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PrivateMembershipRlweOprfRequest* internal_default_instance() {
    return reinterpret_cast<const PrivateMembershipRlweOprfRequest*>(
               &_PrivateMembershipRlweOprfRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(PrivateMembershipRlweOprfRequest& a, PrivateMembershipRlweOprfRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(PrivateMembershipRlweOprfRequest* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PrivateMembershipRlweOprfRequest* New() const final {
    return CreateMaybeMessage<PrivateMembershipRlweOprfRequest>(nullptr);
  }

  PrivateMembershipRlweOprfRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PrivateMembershipRlweOprfRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const PrivateMembershipRlweOprfRequest& from);
  void MergeFrom(const PrivateMembershipRlweOprfRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PrivateMembershipRlweOprfRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.PrivateMembershipRlweOprfRequest";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEncryptedIdsFieldNumber = 1,
    kUseCaseFieldNumber = 2,
  };
  // repeated bytes encrypted_ids = 1;
  int encrypted_ids_size() const;
  private:
  int _internal_encrypted_ids_size() const;
  public:
  void clear_encrypted_ids();
  const std::string& encrypted_ids(int index) const;
  std::string* mutable_encrypted_ids(int index);
  void set_encrypted_ids(int index, const std::string& value);
  void set_encrypted_ids(int index, std::string&& value);
  void set_encrypted_ids(int index, const char* value);
  void set_encrypted_ids(int index, const void* value, size_t size);
  std::string* add_encrypted_ids();
  void add_encrypted_ids(const std::string& value);
  void add_encrypted_ids(std::string&& value);
  void add_encrypted_ids(const char* value);
  void add_encrypted_ids(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& encrypted_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_encrypted_ids();
  private:
  const std::string& _internal_encrypted_ids(int index) const;
  std::string* _internal_add_encrypted_ids();
  public:

  // .private_membership.rlwe.RlweUseCase use_case = 2;
  void clear_use_case();
  ::private_membership::rlwe::RlweUseCase use_case() const;
  void set_use_case(::private_membership::rlwe::RlweUseCase value);
  private:
  ::private_membership::rlwe::RlweUseCase _internal_use_case() const;
  void _internal_set_use_case(::private_membership::rlwe::RlweUseCase value);
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.PrivateMembershipRlweOprfRequest)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> encrypted_ids_;
  int use_case_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class PrivateMembershipRlweOprfResponse :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.PrivateMembershipRlweOprfResponse) */ {
 public:
  PrivateMembershipRlweOprfResponse();
  virtual ~PrivateMembershipRlweOprfResponse();

  PrivateMembershipRlweOprfResponse(const PrivateMembershipRlweOprfResponse& from);
  PrivateMembershipRlweOprfResponse(PrivateMembershipRlweOprfResponse&& from) noexcept
    : PrivateMembershipRlweOprfResponse() {
    *this = ::std::move(from);
  }

  inline PrivateMembershipRlweOprfResponse& operator=(const PrivateMembershipRlweOprfResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrivateMembershipRlweOprfResponse& operator=(PrivateMembershipRlweOprfResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const PrivateMembershipRlweOprfResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PrivateMembershipRlweOprfResponse* internal_default_instance() {
    return reinterpret_cast<const PrivateMembershipRlweOprfResponse*>(
               &_PrivateMembershipRlweOprfResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(PrivateMembershipRlweOprfResponse& a, PrivateMembershipRlweOprfResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(PrivateMembershipRlweOprfResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PrivateMembershipRlweOprfResponse* New() const final {
    return CreateMaybeMessage<PrivateMembershipRlweOprfResponse>(nullptr);
  }

  PrivateMembershipRlweOprfResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PrivateMembershipRlweOprfResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const PrivateMembershipRlweOprfResponse& from);
  void MergeFrom(const PrivateMembershipRlweOprfResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PrivateMembershipRlweOprfResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.PrivateMembershipRlweOprfResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDoublyEncryptedIdsFieldNumber = 1,
    kHashedBucketsParametersFieldNumber = 2,
    kEncryptedBucketsParametersFieldNumber = 3,
    kRlweParametersFieldNumber = 4,
    kKeyVersionFieldNumber = 5,
  };
  // repeated .private_membership.DoublyEncryptedId doubly_encrypted_ids = 1;
  int doubly_encrypted_ids_size() const;
  private:
  int _internal_doubly_encrypted_ids_size() const;
  public:
  void clear_doubly_encrypted_ids();
  ::private_membership::DoublyEncryptedId* mutable_doubly_encrypted_ids(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::DoublyEncryptedId >*
      mutable_doubly_encrypted_ids();
  private:
  const ::private_membership::DoublyEncryptedId& _internal_doubly_encrypted_ids(int index) const;
  ::private_membership::DoublyEncryptedId* _internal_add_doubly_encrypted_ids();
  public:
  const ::private_membership::DoublyEncryptedId& doubly_encrypted_ids(int index) const;
  ::private_membership::DoublyEncryptedId* add_doubly_encrypted_ids();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::DoublyEncryptedId >&
      doubly_encrypted_ids() const;

  // .private_membership.rlwe.HashedBucketsParameters hashed_buckets_parameters = 2;
  bool has_hashed_buckets_parameters() const;
  private:
  bool _internal_has_hashed_buckets_parameters() const;
  public:
  void clear_hashed_buckets_parameters();
  const ::private_membership::rlwe::HashedBucketsParameters& hashed_buckets_parameters() const;
  ::private_membership::rlwe::HashedBucketsParameters* release_hashed_buckets_parameters();
  ::private_membership::rlwe::HashedBucketsParameters* mutable_hashed_buckets_parameters();
  void set_allocated_hashed_buckets_parameters(::private_membership::rlwe::HashedBucketsParameters* hashed_buckets_parameters);
  private:
  const ::private_membership::rlwe::HashedBucketsParameters& _internal_hashed_buckets_parameters() const;
  ::private_membership::rlwe::HashedBucketsParameters* _internal_mutable_hashed_buckets_parameters();
  public:

  // .private_membership.rlwe.EncryptedBucketsParameters encrypted_buckets_parameters = 3;
  bool has_encrypted_buckets_parameters() const;
  private:
  bool _internal_has_encrypted_buckets_parameters() const;
  public:
  void clear_encrypted_buckets_parameters();
  const ::private_membership::rlwe::EncryptedBucketsParameters& encrypted_buckets_parameters() const;
  ::private_membership::rlwe::EncryptedBucketsParameters* release_encrypted_buckets_parameters();
  ::private_membership::rlwe::EncryptedBucketsParameters* mutable_encrypted_buckets_parameters();
  void set_allocated_encrypted_buckets_parameters(::private_membership::rlwe::EncryptedBucketsParameters* encrypted_buckets_parameters);
  private:
  const ::private_membership::rlwe::EncryptedBucketsParameters& _internal_encrypted_buckets_parameters() const;
  ::private_membership::rlwe::EncryptedBucketsParameters* _internal_mutable_encrypted_buckets_parameters();
  public:

  // .private_membership.rlwe.RlweParameters rlwe_parameters = 4;
  bool has_rlwe_parameters() const;
  private:
  bool _internal_has_rlwe_parameters() const;
  public:
  void clear_rlwe_parameters();
  const ::private_membership::rlwe::RlweParameters& rlwe_parameters() const;
  ::private_membership::rlwe::RlweParameters* release_rlwe_parameters();
  ::private_membership::rlwe::RlweParameters* mutable_rlwe_parameters();
  void set_allocated_rlwe_parameters(::private_membership::rlwe::RlweParameters* rlwe_parameters);
  private:
  const ::private_membership::rlwe::RlweParameters& _internal_rlwe_parameters() const;
  ::private_membership::rlwe::RlweParameters* _internal_mutable_rlwe_parameters();
  public:

  // int64 key_version = 5;
  void clear_key_version();
  ::PROTOBUF_NAMESPACE_ID::int64 key_version() const;
  void set_key_version(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_key_version() const;
  void _internal_set_key_version(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.PrivateMembershipRlweOprfResponse)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::DoublyEncryptedId > doubly_encrypted_ids_;
  ::private_membership::rlwe::HashedBucketsParameters* hashed_buckets_parameters_;
  ::private_membership::rlwe::EncryptedBucketsParameters* encrypted_buckets_parameters_;
  ::private_membership::rlwe::RlweParameters* rlwe_parameters_;
  ::PROTOBUF_NAMESPACE_ID::int64 key_version_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class PrivateMembershipRlweQueryRequest :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.PrivateMembershipRlweQueryRequest) */ {
 public:
  PrivateMembershipRlweQueryRequest();
  virtual ~PrivateMembershipRlweQueryRequest();

  PrivateMembershipRlweQueryRequest(const PrivateMembershipRlweQueryRequest& from);
  PrivateMembershipRlweQueryRequest(PrivateMembershipRlweQueryRequest&& from) noexcept
    : PrivateMembershipRlweQueryRequest() {
    *this = ::std::move(from);
  }

  inline PrivateMembershipRlweQueryRequest& operator=(const PrivateMembershipRlweQueryRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrivateMembershipRlweQueryRequest& operator=(PrivateMembershipRlweQueryRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const PrivateMembershipRlweQueryRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PrivateMembershipRlweQueryRequest* internal_default_instance() {
    return reinterpret_cast<const PrivateMembershipRlweQueryRequest*>(
               &_PrivateMembershipRlweQueryRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(PrivateMembershipRlweQueryRequest& a, PrivateMembershipRlweQueryRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(PrivateMembershipRlweQueryRequest* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PrivateMembershipRlweQueryRequest* New() const final {
    return CreateMaybeMessage<PrivateMembershipRlweQueryRequest>(nullptr);
  }

  PrivateMembershipRlweQueryRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PrivateMembershipRlweQueryRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const PrivateMembershipRlweQueryRequest& from);
  void MergeFrom(const PrivateMembershipRlweQueryRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PrivateMembershipRlweQueryRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.PrivateMembershipRlweQueryRequest";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kQueriesFieldNumber = 1,
    kKeyVersionFieldNumber = 3,
    kUseCaseFieldNumber = 2,
  };
  // repeated .private_membership.rlwe.PrivateMembershipRlweQuery queries = 1;
  int queries_size() const;
  private:
  int _internal_queries_size() const;
  public:
  void clear_queries();
  ::private_membership::rlwe::PrivateMembershipRlweQuery* mutable_queries(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::PrivateMembershipRlweQuery >*
      mutable_queries();
  private:
  const ::private_membership::rlwe::PrivateMembershipRlweQuery& _internal_queries(int index) const;
  ::private_membership::rlwe::PrivateMembershipRlweQuery* _internal_add_queries();
  public:
  const ::private_membership::rlwe::PrivateMembershipRlweQuery& queries(int index) const;
  ::private_membership::rlwe::PrivateMembershipRlweQuery* add_queries();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::PrivateMembershipRlweQuery >&
      queries() const;

  // int64 key_version = 3;
  void clear_key_version();
  ::PROTOBUF_NAMESPACE_ID::int64 key_version() const;
  void set_key_version(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_key_version() const;
  void _internal_set_key_version(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // .private_membership.rlwe.RlweUseCase use_case = 2;
  void clear_use_case();
  ::private_membership::rlwe::RlweUseCase use_case() const;
  void set_use_case(::private_membership::rlwe::RlweUseCase value);
  private:
  ::private_membership::rlwe::RlweUseCase _internal_use_case() const;
  void _internal_set_use_case(::private_membership::rlwe::RlweUseCase value);
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.PrivateMembershipRlweQueryRequest)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::PrivateMembershipRlweQuery > queries_;
  ::PROTOBUF_NAMESPACE_ID::int64 key_version_;
  int use_case_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class PrivateMembershipRlweQueryResponse :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.PrivateMembershipRlweQueryResponse) */ {
 public:
  PrivateMembershipRlweQueryResponse();
  virtual ~PrivateMembershipRlweQueryResponse();

  PrivateMembershipRlweQueryResponse(const PrivateMembershipRlweQueryResponse& from);
  PrivateMembershipRlweQueryResponse(PrivateMembershipRlweQueryResponse&& from) noexcept
    : PrivateMembershipRlweQueryResponse() {
    *this = ::std::move(from);
  }

  inline PrivateMembershipRlweQueryResponse& operator=(const PrivateMembershipRlweQueryResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrivateMembershipRlweQueryResponse& operator=(PrivateMembershipRlweQueryResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const PrivateMembershipRlweQueryResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PrivateMembershipRlweQueryResponse* internal_default_instance() {
    return reinterpret_cast<const PrivateMembershipRlweQueryResponse*>(
               &_PrivateMembershipRlweQueryResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(PrivateMembershipRlweQueryResponse& a, PrivateMembershipRlweQueryResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(PrivateMembershipRlweQueryResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PrivateMembershipRlweQueryResponse* New() const final {
    return CreateMaybeMessage<PrivateMembershipRlweQueryResponse>(nullptr);
  }

  PrivateMembershipRlweQueryResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PrivateMembershipRlweQueryResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const PrivateMembershipRlweQueryResponse& from);
  void MergeFrom(const PrivateMembershipRlweQueryResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PrivateMembershipRlweQueryResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.PrivateMembershipRlweQueryResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPirResponsesFieldNumber = 1,
  };
  // repeated .private_membership.rlwe.PrivateMembershipRlwePirResponse pir_responses = 1;
  int pir_responses_size() const;
  private:
  int _internal_pir_responses_size() const;
  public:
  void clear_pir_responses();
  ::private_membership::rlwe::PrivateMembershipRlwePirResponse* mutable_pir_responses(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::PrivateMembershipRlwePirResponse >*
      mutable_pir_responses();
  private:
  const ::private_membership::rlwe::PrivateMembershipRlwePirResponse& _internal_pir_responses(int index) const;
  ::private_membership::rlwe::PrivateMembershipRlwePirResponse* _internal_add_pir_responses();
  public:
  const ::private_membership::rlwe::PrivateMembershipRlwePirResponse& pir_responses(int index) const;
  ::private_membership::rlwe::PrivateMembershipRlwePirResponse* add_pir_responses();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::PrivateMembershipRlwePirResponse >&
      pir_responses() const;

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.PrivateMembershipRlweQueryResponse)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::PrivateMembershipRlwePirResponse > pir_responses_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class RlwePlaintextId :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.RlwePlaintextId) */ {
 public:
  RlwePlaintextId();
  virtual ~RlwePlaintextId();

  RlwePlaintextId(const RlwePlaintextId& from);
  RlwePlaintextId(RlwePlaintextId&& from) noexcept
    : RlwePlaintextId() {
    *this = ::std::move(from);
  }

  inline RlwePlaintextId& operator=(const RlwePlaintextId& from) {
    CopyFrom(from);
    return *this;
  }
  inline RlwePlaintextId& operator=(RlwePlaintextId&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const RlwePlaintextId& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RlwePlaintextId* internal_default_instance() {
    return reinterpret_cast<const RlwePlaintextId*>(
               &_RlwePlaintextId_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(RlwePlaintextId& a, RlwePlaintextId& b) {
    a.Swap(&b);
  }
  inline void Swap(RlwePlaintextId* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RlwePlaintextId* New() const final {
    return CreateMaybeMessage<RlwePlaintextId>(nullptr);
  }

  RlwePlaintextId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RlwePlaintextId>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const RlwePlaintextId& from);
  void MergeFrom(const RlwePlaintextId& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RlwePlaintextId* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.RlwePlaintextId";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNonSensitiveIdFieldNumber = 1,
    kSensitiveIdFieldNumber = 2,
  };
  // string non_sensitive_id = 1;
  void clear_non_sensitive_id();
  const std::string& non_sensitive_id() const;
  void set_non_sensitive_id(const std::string& value);
  void set_non_sensitive_id(std::string&& value);
  void set_non_sensitive_id(const char* value);
  void set_non_sensitive_id(const char* value, size_t size);
  std::string* mutable_non_sensitive_id();
  std::string* release_non_sensitive_id();
  void set_allocated_non_sensitive_id(std::string* non_sensitive_id);
  private:
  const std::string& _internal_non_sensitive_id() const;
  void _internal_set_non_sensitive_id(const std::string& value);
  std::string* _internal_mutable_non_sensitive_id();
  public:

  // string sensitive_id = 2;
  void clear_sensitive_id();
  const std::string& sensitive_id() const;
  void set_sensitive_id(const std::string& value);
  void set_sensitive_id(std::string&& value);
  void set_sensitive_id(const char* value);
  void set_sensitive_id(const char* value, size_t size);
  std::string* mutable_sensitive_id();
  std::string* release_sensitive_id();
  void set_allocated_sensitive_id(std::string* sensitive_id);
  private:
  const std::string& _internal_sensitive_id() const;
  void _internal_set_sensitive_id(const std::string& value);
  std::string* _internal_mutable_sensitive_id();
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.RlwePlaintextId)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr non_sensitive_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sensitive_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class HashedBucketsParameters :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.HashedBucketsParameters) */ {
 public:
  HashedBucketsParameters();
  virtual ~HashedBucketsParameters();

  HashedBucketsParameters(const HashedBucketsParameters& from);
  HashedBucketsParameters(HashedBucketsParameters&& from) noexcept
    : HashedBucketsParameters() {
    *this = ::std::move(from);
  }

  inline HashedBucketsParameters& operator=(const HashedBucketsParameters& from) {
    CopyFrom(from);
    return *this;
  }
  inline HashedBucketsParameters& operator=(HashedBucketsParameters&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const HashedBucketsParameters& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const HashedBucketsParameters* internal_default_instance() {
    return reinterpret_cast<const HashedBucketsParameters*>(
               &_HashedBucketsParameters_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(HashedBucketsParameters& a, HashedBucketsParameters& b) {
    a.Swap(&b);
  }
  inline void Swap(HashedBucketsParameters* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline HashedBucketsParameters* New() const final {
    return CreateMaybeMessage<HashedBucketsParameters>(nullptr);
  }

  HashedBucketsParameters* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<HashedBucketsParameters>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const HashedBucketsParameters& from);
  void MergeFrom(const HashedBucketsParameters& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(HashedBucketsParameters* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.HashedBucketsParameters";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kHashedBucketIdLengthFieldNumber = 1,
    kNonSensitiveIdHashTypeFieldNumber = 2,
  };
  // int32 hashed_bucket_id_length = 1;
  void clear_hashed_bucket_id_length();
  ::PROTOBUF_NAMESPACE_ID::int32 hashed_bucket_id_length() const;
  void set_hashed_bucket_id_length(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_hashed_bucket_id_length() const;
  void _internal_set_hashed_bucket_id_length(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // .private_membership.HashType non_sensitive_id_hash_type = 2;
  void clear_non_sensitive_id_hash_type();
  ::private_membership::HashType non_sensitive_id_hash_type() const;
  void set_non_sensitive_id_hash_type(::private_membership::HashType value);
  private:
  ::private_membership::HashType _internal_non_sensitive_id_hash_type() const;
  void _internal_set_non_sensitive_id_hash_type(::private_membership::HashType value);
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.HashedBucketsParameters)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::int32 hashed_bucket_id_length_;
  int non_sensitive_id_hash_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class EncryptedBucketsParameters :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.EncryptedBucketsParameters) */ {
 public:
  EncryptedBucketsParameters();
  virtual ~EncryptedBucketsParameters();

  EncryptedBucketsParameters(const EncryptedBucketsParameters& from);
  EncryptedBucketsParameters(EncryptedBucketsParameters&& from) noexcept
    : EncryptedBucketsParameters() {
    *this = ::std::move(from);
  }

  inline EncryptedBucketsParameters& operator=(const EncryptedBucketsParameters& from) {
    CopyFrom(from);
    return *this;
  }
  inline EncryptedBucketsParameters& operator=(EncryptedBucketsParameters&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const EncryptedBucketsParameters& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const EncryptedBucketsParameters* internal_default_instance() {
    return reinterpret_cast<const EncryptedBucketsParameters*>(
               &_EncryptedBucketsParameters_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(EncryptedBucketsParameters& a, EncryptedBucketsParameters& b) {
    a.Swap(&b);
  }
  inline void Swap(EncryptedBucketsParameters* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline EncryptedBucketsParameters* New() const final {
    return CreateMaybeMessage<EncryptedBucketsParameters>(nullptr);
  }

  EncryptedBucketsParameters* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<EncryptedBucketsParameters>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const EncryptedBucketsParameters& from);
  void MergeFrom(const EncryptedBucketsParameters& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(EncryptedBucketsParameters* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.EncryptedBucketsParameters";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEncryptedBucketIdLengthFieldNumber = 1,
    kSensitiveIdHashTypeFieldNumber = 2,
  };
  // int32 encrypted_bucket_id_length = 1;
  void clear_encrypted_bucket_id_length();
  ::PROTOBUF_NAMESPACE_ID::int32 encrypted_bucket_id_length() const;
  void set_encrypted_bucket_id_length(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_encrypted_bucket_id_length() const;
  void _internal_set_encrypted_bucket_id_length(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // .private_membership.EncryptedBucketHashType sensitive_id_hash_type = 2;
  void clear_sensitive_id_hash_type();
  ::private_membership::EncryptedBucketHashType sensitive_id_hash_type() const;
  void set_sensitive_id_hash_type(::private_membership::EncryptedBucketHashType value);
  private:
  ::private_membership::EncryptedBucketHashType _internal_sensitive_id_hash_type() const;
  void _internal_set_sensitive_id_hash_type(::private_membership::EncryptedBucketHashType value);
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.EncryptedBucketsParameters)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::int32 encrypted_bucket_id_length_;
  int sensitive_id_hash_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class RlweParameters :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.RlweParameters) */ {
 public:
  RlweParameters();
  virtual ~RlweParameters();

  RlweParameters(const RlweParameters& from);
  RlweParameters(RlweParameters&& from) noexcept
    : RlweParameters() {
    *this = ::std::move(from);
  }

  inline RlweParameters& operator=(const RlweParameters& from) {
    CopyFrom(from);
    return *this;
  }
  inline RlweParameters& operator=(RlweParameters&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const RlweParameters& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RlweParameters* internal_default_instance() {
    return reinterpret_cast<const RlweParameters*>(
               &_RlweParameters_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(RlweParameters& a, RlweParameters& b) {
    a.Swap(&b);
  }
  inline void Swap(RlweParameters* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RlweParameters* New() const final {
    return CreateMaybeMessage<RlweParameters>(nullptr);
  }

  RlweParameters* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RlweParameters>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const RlweParameters& from);
  void MergeFrom(const RlweParameters& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RlweParameters* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.RlweParameters";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kModulusFieldNumber = 1,
    kLogDegreeFieldNumber = 2,
    kLogTFieldNumber = 3,
    kVarianceFieldNumber = 4,
    kLevelsOfRecursionFieldNumber = 5,
  };
  // repeated .private_membership.rlwe.Uint128 modulus = 1;
  int modulus_size() const;
  private:
  int _internal_modulus_size() const;
  public:
  void clear_modulus();
  ::private_membership::rlwe::Uint128* mutable_modulus(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::Uint128 >*
      mutable_modulus();
  private:
  const ::private_membership::rlwe::Uint128& _internal_modulus(int index) const;
  ::private_membership::rlwe::Uint128* _internal_add_modulus();
  public:
  const ::private_membership::rlwe::Uint128& modulus(int index) const;
  ::private_membership::rlwe::Uint128* add_modulus();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::Uint128 >&
      modulus() const;

  // int32 log_degree = 2;
  void clear_log_degree();
  ::PROTOBUF_NAMESPACE_ID::int32 log_degree() const;
  void set_log_degree(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_log_degree() const;
  void _internal_set_log_degree(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 log_t = 3;
  void clear_log_t();
  ::PROTOBUF_NAMESPACE_ID::int32 log_t() const;
  void set_log_t(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_log_t() const;
  void _internal_set_log_t(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 variance = 4;
  void clear_variance();
  ::PROTOBUF_NAMESPACE_ID::int32 variance() const;
  void set_variance(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_variance() const;
  void _internal_set_variance(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 levels_of_recursion = 5;
  void clear_levels_of_recursion();
  ::PROTOBUF_NAMESPACE_ID::int32 levels_of_recursion() const;
  void set_levels_of_recursion(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_levels_of_recursion() const;
  void _internal_set_levels_of_recursion(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.RlweParameters)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::Uint128 > modulus_;
  ::PROTOBUF_NAMESPACE_ID::int32 log_degree_;
  ::PROTOBUF_NAMESPACE_ID::int32 log_t_;
  ::PROTOBUF_NAMESPACE_ID::int32 variance_;
  ::PROTOBUF_NAMESPACE_ID::int32 levels_of_recursion_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class Uint128 :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.Uint128) */ {
 public:
  Uint128();
  virtual ~Uint128();

  Uint128(const Uint128& from);
  Uint128(Uint128&& from) noexcept
    : Uint128() {
    *this = ::std::move(from);
  }

  inline Uint128& operator=(const Uint128& from) {
    CopyFrom(from);
    return *this;
  }
  inline Uint128& operator=(Uint128&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const Uint128& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Uint128* internal_default_instance() {
    return reinterpret_cast<const Uint128*>(
               &_Uint128_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(Uint128& a, Uint128& b) {
    a.Swap(&b);
  }
  inline void Swap(Uint128* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Uint128* New() const final {
    return CreateMaybeMessage<Uint128>(nullptr);
  }

  Uint128* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Uint128>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const Uint128& from);
  void MergeFrom(const Uint128& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Uint128* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.Uint128";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLoFieldNumber = 1,
    kHiFieldNumber = 2,
  };
  // uint64 lo = 1;
  void clear_lo();
  ::PROTOBUF_NAMESPACE_ID::uint64 lo() const;
  void set_lo(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_lo() const;
  void _internal_set_lo(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // uint64 hi = 2;
  void clear_hi();
  ::PROTOBUF_NAMESPACE_ID::uint64 hi() const;
  void set_hi(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_hi() const;
  void _internal_set_hi(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.Uint128)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::uint64 lo_;
  ::PROTOBUF_NAMESPACE_ID::uint64 hi_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class PrivateMembershipRlweQuery_HashedBucketId :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId) */ {
 public:
  PrivateMembershipRlweQuery_HashedBucketId();
  virtual ~PrivateMembershipRlweQuery_HashedBucketId();

  PrivateMembershipRlweQuery_HashedBucketId(const PrivateMembershipRlweQuery_HashedBucketId& from);
  PrivateMembershipRlweQuery_HashedBucketId(PrivateMembershipRlweQuery_HashedBucketId&& from) noexcept
    : PrivateMembershipRlweQuery_HashedBucketId() {
    *this = ::std::move(from);
  }

  inline PrivateMembershipRlweQuery_HashedBucketId& operator=(const PrivateMembershipRlweQuery_HashedBucketId& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrivateMembershipRlweQuery_HashedBucketId& operator=(PrivateMembershipRlweQuery_HashedBucketId&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const PrivateMembershipRlweQuery_HashedBucketId& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PrivateMembershipRlweQuery_HashedBucketId* internal_default_instance() {
    return reinterpret_cast<const PrivateMembershipRlweQuery_HashedBucketId*>(
               &_PrivateMembershipRlweQuery_HashedBucketId_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(PrivateMembershipRlweQuery_HashedBucketId& a, PrivateMembershipRlweQuery_HashedBucketId& b) {
    a.Swap(&b);
  }
  inline void Swap(PrivateMembershipRlweQuery_HashedBucketId* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PrivateMembershipRlweQuery_HashedBucketId* New() const final {
    return CreateMaybeMessage<PrivateMembershipRlweQuery_HashedBucketId>(nullptr);
  }

  PrivateMembershipRlweQuery_HashedBucketId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PrivateMembershipRlweQuery_HashedBucketId>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const PrivateMembershipRlweQuery_HashedBucketId& from);
  void MergeFrom(const PrivateMembershipRlweQuery_HashedBucketId& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PrivateMembershipRlweQuery_HashedBucketId* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kHashedBucketIdFieldNumber = 1,
    kBitLengthFieldNumber = 2,
  };
  // bytes hashed_bucket_id = 1;
  void clear_hashed_bucket_id();
  const std::string& hashed_bucket_id() const;
  void set_hashed_bucket_id(const std::string& value);
  void set_hashed_bucket_id(std::string&& value);
  void set_hashed_bucket_id(const char* value);
  void set_hashed_bucket_id(const void* value, size_t size);
  std::string* mutable_hashed_bucket_id();
  std::string* release_hashed_bucket_id();
  void set_allocated_hashed_bucket_id(std::string* hashed_bucket_id);
  private:
  const std::string& _internal_hashed_bucket_id() const;
  void _internal_set_hashed_bucket_id(const std::string& value);
  std::string* _internal_mutable_hashed_bucket_id();
  public:

  // int32 bit_length = 2;
  void clear_bit_length();
  ::PROTOBUF_NAMESPACE_ID::int32 bit_length() const;
  void set_bit_length(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_bit_length() const;
  void _internal_set_bit_length(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hashed_bucket_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 bit_length_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class PrivateMembershipRlweQuery :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.PrivateMembershipRlweQuery) */ {
 public:
  PrivateMembershipRlweQuery();
  virtual ~PrivateMembershipRlweQuery();

  PrivateMembershipRlweQuery(const PrivateMembershipRlweQuery& from);
  PrivateMembershipRlweQuery(PrivateMembershipRlweQuery&& from) noexcept
    : PrivateMembershipRlweQuery() {
    *this = ::std::move(from);
  }

  inline PrivateMembershipRlweQuery& operator=(const PrivateMembershipRlweQuery& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrivateMembershipRlweQuery& operator=(PrivateMembershipRlweQuery&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const PrivateMembershipRlweQuery& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PrivateMembershipRlweQuery* internal_default_instance() {
    return reinterpret_cast<const PrivateMembershipRlweQuery*>(
               &_PrivateMembershipRlweQuery_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(PrivateMembershipRlweQuery& a, PrivateMembershipRlweQuery& b) {
    a.Swap(&b);
  }
  inline void Swap(PrivateMembershipRlweQuery* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PrivateMembershipRlweQuery* New() const final {
    return CreateMaybeMessage<PrivateMembershipRlweQuery>(nullptr);
  }

  PrivateMembershipRlweQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PrivateMembershipRlweQuery>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const PrivateMembershipRlweQuery& from);
  void MergeFrom(const PrivateMembershipRlweQuery& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PrivateMembershipRlweQuery* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.PrivateMembershipRlweQuery";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef PrivateMembershipRlweQuery_HashedBucketId HashedBucketId;

  // accessors -------------------------------------------------------

  enum : int {
    kQueriedEncryptedIdFieldNumber = 1,
    kPirRequestFieldNumber = 2,
    kHashedBucketIdFieldNumber = 3,
  };
  // bytes queried_encrypted_id = 1;
  void clear_queried_encrypted_id();
  const std::string& queried_encrypted_id() const;
  void set_queried_encrypted_id(const std::string& value);
  void set_queried_encrypted_id(std::string&& value);
  void set_queried_encrypted_id(const char* value);
  void set_queried_encrypted_id(const void* value, size_t size);
  std::string* mutable_queried_encrypted_id();
  std::string* release_queried_encrypted_id();
  void set_allocated_queried_encrypted_id(std::string* queried_encrypted_id);
  private:
  const std::string& _internal_queried_encrypted_id() const;
  void _internal_set_queried_encrypted_id(const std::string& value);
  std::string* _internal_mutable_queried_encrypted_id();
  public:

  // .private_membership.rlwe.PirRequest pir_request = 2;
  bool has_pir_request() const;
  private:
  bool _internal_has_pir_request() const;
  public:
  void clear_pir_request();
  const ::private_membership::rlwe::PirRequest& pir_request() const;
  ::private_membership::rlwe::PirRequest* release_pir_request();
  ::private_membership::rlwe::PirRequest* mutable_pir_request();
  void set_allocated_pir_request(::private_membership::rlwe::PirRequest* pir_request);
  private:
  const ::private_membership::rlwe::PirRequest& _internal_pir_request() const;
  ::private_membership::rlwe::PirRequest* _internal_mutable_pir_request();
  public:

  // .private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId hashed_bucket_id = 3;
  bool has_hashed_bucket_id() const;
  private:
  bool _internal_has_hashed_bucket_id() const;
  public:
  void clear_hashed_bucket_id();
  const ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId& hashed_bucket_id() const;
  ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* release_hashed_bucket_id();
  ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* mutable_hashed_bucket_id();
  void set_allocated_hashed_bucket_id(::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* hashed_bucket_id);
  private:
  const ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId& _internal_hashed_bucket_id() const;
  ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* _internal_mutable_hashed_bucket_id();
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.PrivateMembershipRlweQuery)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr queried_encrypted_id_;
  ::private_membership::rlwe::PirRequest* pir_request_;
  ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* hashed_bucket_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class PrivateMembershipRlwePirResponse :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.PrivateMembershipRlwePirResponse) */ {
 public:
  PrivateMembershipRlwePirResponse();
  virtual ~PrivateMembershipRlwePirResponse();

  PrivateMembershipRlwePirResponse(const PrivateMembershipRlwePirResponse& from);
  PrivateMembershipRlwePirResponse(PrivateMembershipRlwePirResponse&& from) noexcept
    : PrivateMembershipRlwePirResponse() {
    *this = ::std::move(from);
  }

  inline PrivateMembershipRlwePirResponse& operator=(const PrivateMembershipRlwePirResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrivateMembershipRlwePirResponse& operator=(PrivateMembershipRlwePirResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const PrivateMembershipRlwePirResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PrivateMembershipRlwePirResponse* internal_default_instance() {
    return reinterpret_cast<const PrivateMembershipRlwePirResponse*>(
               &_PrivateMembershipRlwePirResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(PrivateMembershipRlwePirResponse& a, PrivateMembershipRlwePirResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(PrivateMembershipRlwePirResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PrivateMembershipRlwePirResponse* New() const final {
    return CreateMaybeMessage<PrivateMembershipRlwePirResponse>(nullptr);
  }

  PrivateMembershipRlwePirResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PrivateMembershipRlwePirResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const PrivateMembershipRlwePirResponse& from);
  void MergeFrom(const PrivateMembershipRlwePirResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PrivateMembershipRlwePirResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.PrivateMembershipRlwePirResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kQueriedEncryptedIdFieldNumber = 1,
    kPirResponseFieldNumber = 2,
  };
  // bytes queried_encrypted_id = 1;
  void clear_queried_encrypted_id();
  const std::string& queried_encrypted_id() const;
  void set_queried_encrypted_id(const std::string& value);
  void set_queried_encrypted_id(std::string&& value);
  void set_queried_encrypted_id(const char* value);
  void set_queried_encrypted_id(const void* value, size_t size);
  std::string* mutable_queried_encrypted_id();
  std::string* release_queried_encrypted_id();
  void set_allocated_queried_encrypted_id(std::string* queried_encrypted_id);
  private:
  const std::string& _internal_queried_encrypted_id() const;
  void _internal_set_queried_encrypted_id(const std::string& value);
  std::string* _internal_mutable_queried_encrypted_id();
  public:

  // .private_membership.rlwe.PirResponse pir_response = 2;
  bool has_pir_response() const;
  private:
  bool _internal_has_pir_response() const;
  public:
  void clear_pir_response();
  const ::private_membership::rlwe::PirResponse& pir_response() const;
  ::private_membership::rlwe::PirResponse* release_pir_response();
  ::private_membership::rlwe::PirResponse* mutable_pir_response();
  void set_allocated_pir_response(::private_membership::rlwe::PirResponse* pir_response);
  private:
  const ::private_membership::rlwe::PirResponse& _internal_pir_response() const;
  ::private_membership::rlwe::PirResponse* _internal_mutable_pir_response();
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.PrivateMembershipRlwePirResponse)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr queried_encrypted_id_;
  ::private_membership::rlwe::PirResponse* pir_response_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class PirRequest :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.PirRequest) */ {
 public:
  PirRequest();
  virtual ~PirRequest();

  PirRequest(const PirRequest& from);
  PirRequest(PirRequest&& from) noexcept
    : PirRequest() {
    *this = ::std::move(from);
  }

  inline PirRequest& operator=(const PirRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline PirRequest& operator=(PirRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const PirRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PirRequest* internal_default_instance() {
    return reinterpret_cast<const PirRequest*>(
               &_PirRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(PirRequest& a, PirRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(PirRequest* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PirRequest* New() const final {
    return CreateMaybeMessage<PirRequest>(nullptr);
  }

  PirRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PirRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const PirRequest& from);
  void MergeFrom(const PirRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PirRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.PirRequest";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRequestFieldNumber = 1,
    kPrngSeedFieldNumber = 2,
  };
  // repeated .rlwe.SerializedNttPolynomial request = 1;
  int request_size() const;
  private:
  int _internal_request_size() const;
  public:
  void clear_request();
  ::rlwe::SerializedNttPolynomial* mutable_request(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rlwe::SerializedNttPolynomial >*
      mutable_request();
  private:
  const ::rlwe::SerializedNttPolynomial& _internal_request(int index) const;
  ::rlwe::SerializedNttPolynomial* _internal_add_request();
  public:
  const ::rlwe::SerializedNttPolynomial& request(int index) const;
  ::rlwe::SerializedNttPolynomial* add_request();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rlwe::SerializedNttPolynomial >&
      request() const;

  // bytes prng_seed = 2;
  void clear_prng_seed();
  const std::string& prng_seed() const;
  void set_prng_seed(const std::string& value);
  void set_prng_seed(std::string&& value);
  void set_prng_seed(const char* value);
  void set_prng_seed(const void* value, size_t size);
  std::string* mutable_prng_seed();
  std::string* release_prng_seed();
  void set_allocated_prng_seed(std::string* prng_seed);
  private:
  const std::string& _internal_prng_seed() const;
  void _internal_set_prng_seed(const std::string& value);
  std::string* _internal_mutable_prng_seed();
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.PirRequest)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rlwe::SerializedNttPolynomial > request_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prng_seed_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class PirResponse :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.PirResponse) */ {
 public:
  PirResponse();
  virtual ~PirResponse();

  PirResponse(const PirResponse& from);
  PirResponse(PirResponse&& from) noexcept
    : PirResponse() {
    *this = ::std::move(from);
  }

  inline PirResponse& operator=(const PirResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline PirResponse& operator=(PirResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const PirResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PirResponse* internal_default_instance() {
    return reinterpret_cast<const PirResponse*>(
               &_PirResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(PirResponse& a, PirResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(PirResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline PirResponse* New() const final {
    return CreateMaybeMessage<PirResponse>(nullptr);
  }

  PirResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PirResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const PirResponse& from);
  void MergeFrom(const PirResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PirResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.PirResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kResponseFieldNumber = 1,
    kPlaintextEntrySizeFieldNumber = 2,
  };
  // repeated .rlwe.SerializedSymmetricRlweCiphertext response = 1;
  int response_size() const;
  private:
  int _internal_response_size() const;
  public:
  void clear_response();
  ::rlwe::SerializedSymmetricRlweCiphertext* mutable_response(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rlwe::SerializedSymmetricRlweCiphertext >*
      mutable_response();
  private:
  const ::rlwe::SerializedSymmetricRlweCiphertext& _internal_response(int index) const;
  ::rlwe::SerializedSymmetricRlweCiphertext* _internal_add_response();
  public:
  const ::rlwe::SerializedSymmetricRlweCiphertext& response(int index) const;
  ::rlwe::SerializedSymmetricRlweCiphertext* add_response();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rlwe::SerializedSymmetricRlweCiphertext >&
      response() const;

  // int32 plaintext_entry_size = 2;
  void clear_plaintext_entry_size();
  ::PROTOBUF_NAMESPACE_ID::int32 plaintext_entry_size() const;
  void set_plaintext_entry_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_plaintext_entry_size() const;
  void _internal_set_plaintext_entry_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.PirResponse)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rlwe::SerializedSymmetricRlweCiphertext > response_;
  ::PROTOBUF_NAMESPACE_ID::int32 plaintext_entry_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class EncryptedBucket_EncryptedIdValuePair :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair) */ {
 public:
  EncryptedBucket_EncryptedIdValuePair();
  virtual ~EncryptedBucket_EncryptedIdValuePair();

  EncryptedBucket_EncryptedIdValuePair(const EncryptedBucket_EncryptedIdValuePair& from);
  EncryptedBucket_EncryptedIdValuePair(EncryptedBucket_EncryptedIdValuePair&& from) noexcept
    : EncryptedBucket_EncryptedIdValuePair() {
    *this = ::std::move(from);
  }

  inline EncryptedBucket_EncryptedIdValuePair& operator=(const EncryptedBucket_EncryptedIdValuePair& from) {
    CopyFrom(from);
    return *this;
  }
  inline EncryptedBucket_EncryptedIdValuePair& operator=(EncryptedBucket_EncryptedIdValuePair&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const EncryptedBucket_EncryptedIdValuePair& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const EncryptedBucket_EncryptedIdValuePair* internal_default_instance() {
    return reinterpret_cast<const EncryptedBucket_EncryptedIdValuePair*>(
               &_EncryptedBucket_EncryptedIdValuePair_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(EncryptedBucket_EncryptedIdValuePair& a, EncryptedBucket_EncryptedIdValuePair& b) {
    a.Swap(&b);
  }
  inline void Swap(EncryptedBucket_EncryptedIdValuePair* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline EncryptedBucket_EncryptedIdValuePair* New() const final {
    return CreateMaybeMessage<EncryptedBucket_EncryptedIdValuePair>(nullptr);
  }

  EncryptedBucket_EncryptedIdValuePair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<EncryptedBucket_EncryptedIdValuePair>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const EncryptedBucket_EncryptedIdValuePair& from);
  void MergeFrom(const EncryptedBucket_EncryptedIdValuePair& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(EncryptedBucket_EncryptedIdValuePair* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEncryptedIdFieldNumber = 1,
    kEncryptedValueFieldNumber = 2,
  };
  // bytes encrypted_id = 1;
  void clear_encrypted_id();
  const std::string& encrypted_id() const;
  void set_encrypted_id(const std::string& value);
  void set_encrypted_id(std::string&& value);
  void set_encrypted_id(const char* value);
  void set_encrypted_id(const void* value, size_t size);
  std::string* mutable_encrypted_id();
  std::string* release_encrypted_id();
  void set_allocated_encrypted_id(std::string* encrypted_id);
  private:
  const std::string& _internal_encrypted_id() const;
  void _internal_set_encrypted_id(const std::string& value);
  std::string* _internal_mutable_encrypted_id();
  public:

  // bytes encrypted_value = 2;
  void clear_encrypted_value();
  const std::string& encrypted_value() const;
  void set_encrypted_value(const std::string& value);
  void set_encrypted_value(std::string&& value);
  void set_encrypted_value(const char* value);
  void set_encrypted_value(const void* value, size_t size);
  std::string* mutable_encrypted_value();
  std::string* release_encrypted_value();
  void set_allocated_encrypted_value(std::string* encrypted_value);
  private:
  const std::string& _internal_encrypted_value() const;
  void _internal_set_encrypted_value(const std::string& value);
  std::string* _internal_mutable_encrypted_value();
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class EncryptedBucket :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.EncryptedBucket) */ {
 public:
  EncryptedBucket();
  virtual ~EncryptedBucket();

  EncryptedBucket(const EncryptedBucket& from);
  EncryptedBucket(EncryptedBucket&& from) noexcept
    : EncryptedBucket() {
    *this = ::std::move(from);
  }

  inline EncryptedBucket& operator=(const EncryptedBucket& from) {
    CopyFrom(from);
    return *this;
  }
  inline EncryptedBucket& operator=(EncryptedBucket&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const EncryptedBucket& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const EncryptedBucket* internal_default_instance() {
    return reinterpret_cast<const EncryptedBucket*>(
               &_EncryptedBucket_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(EncryptedBucket& a, EncryptedBucket& b) {
    a.Swap(&b);
  }
  inline void Swap(EncryptedBucket* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline EncryptedBucket* New() const final {
    return CreateMaybeMessage<EncryptedBucket>(nullptr);
  }

  EncryptedBucket* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<EncryptedBucket>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const EncryptedBucket& from);
  void MergeFrom(const EncryptedBucket& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(EncryptedBucket* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.EncryptedBucket";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef EncryptedBucket_EncryptedIdValuePair EncryptedIdValuePair;

  // accessors -------------------------------------------------------

  enum : int {
    kEncryptedIdValuePairsFieldNumber = 1,
  };
  // repeated .private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair encrypted_id_value_pairs = 1;
  int encrypted_id_value_pairs_size() const;
  private:
  int _internal_encrypted_id_value_pairs_size() const;
  public:
  void clear_encrypted_id_value_pairs();
  ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair* mutable_encrypted_id_value_pairs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair >*
      mutable_encrypted_id_value_pairs();
  private:
  const ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair& _internal_encrypted_id_value_pairs(int index) const;
  ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair* _internal_add_encrypted_id_value_pairs();
  public:
  const ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair& encrypted_id_value_pairs(int index) const;
  ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair* add_encrypted_id_value_pairs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair >&
      encrypted_id_value_pairs() const;

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.EncryptedBucket)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair > encrypted_id_value_pairs_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class RlweMembershipResponses_MembershipResponseEntry :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry) */ {
 public:
  RlweMembershipResponses_MembershipResponseEntry();
  virtual ~RlweMembershipResponses_MembershipResponseEntry();

  RlweMembershipResponses_MembershipResponseEntry(const RlweMembershipResponses_MembershipResponseEntry& from);
  RlweMembershipResponses_MembershipResponseEntry(RlweMembershipResponses_MembershipResponseEntry&& from) noexcept
    : RlweMembershipResponses_MembershipResponseEntry() {
    *this = ::std::move(from);
  }

  inline RlweMembershipResponses_MembershipResponseEntry& operator=(const RlweMembershipResponses_MembershipResponseEntry& from) {
    CopyFrom(from);
    return *this;
  }
  inline RlweMembershipResponses_MembershipResponseEntry& operator=(RlweMembershipResponses_MembershipResponseEntry&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const RlweMembershipResponses_MembershipResponseEntry& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RlweMembershipResponses_MembershipResponseEntry* internal_default_instance() {
    return reinterpret_cast<const RlweMembershipResponses_MembershipResponseEntry*>(
               &_RlweMembershipResponses_MembershipResponseEntry_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(RlweMembershipResponses_MembershipResponseEntry& a, RlweMembershipResponses_MembershipResponseEntry& b) {
    a.Swap(&b);
  }
  inline void Swap(RlweMembershipResponses_MembershipResponseEntry* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RlweMembershipResponses_MembershipResponseEntry* New() const final {
    return CreateMaybeMessage<RlweMembershipResponses_MembershipResponseEntry>(nullptr);
  }

  RlweMembershipResponses_MembershipResponseEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RlweMembershipResponses_MembershipResponseEntry>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const RlweMembershipResponses_MembershipResponseEntry& from);
  void MergeFrom(const RlweMembershipResponses_MembershipResponseEntry& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RlweMembershipResponses_MembershipResponseEntry* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPlaintextIdFieldNumber = 1,
    kMembershipResponseFieldNumber = 2,
  };
  // .private_membership.rlwe.RlwePlaintextId plaintext_id = 1;
  bool has_plaintext_id() const;
  private:
  bool _internal_has_plaintext_id() const;
  public:
  void clear_plaintext_id();
  const ::private_membership::rlwe::RlwePlaintextId& plaintext_id() const;
  ::private_membership::rlwe::RlwePlaintextId* release_plaintext_id();
  ::private_membership::rlwe::RlwePlaintextId* mutable_plaintext_id();
  void set_allocated_plaintext_id(::private_membership::rlwe::RlwePlaintextId* plaintext_id);
  private:
  const ::private_membership::rlwe::RlwePlaintextId& _internal_plaintext_id() const;
  ::private_membership::rlwe::RlwePlaintextId* _internal_mutable_plaintext_id();
  public:

  // .private_membership.MembershipResponse membership_response = 2;
  bool has_membership_response() const;
  private:
  bool _internal_has_membership_response() const;
  public:
  void clear_membership_response();
  const ::private_membership::MembershipResponse& membership_response() const;
  ::private_membership::MembershipResponse* release_membership_response();
  ::private_membership::MembershipResponse* mutable_membership_response();
  void set_allocated_membership_response(::private_membership::MembershipResponse* membership_response);
  private:
  const ::private_membership::MembershipResponse& _internal_membership_response() const;
  ::private_membership::MembershipResponse* _internal_mutable_membership_response();
  public:

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::private_membership::rlwe::RlwePlaintextId* plaintext_id_;
  ::private_membership::MembershipResponse* membership_response_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// -------------------------------------------------------------------

class RlweMembershipResponses :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:private_membership.rlwe.RlweMembershipResponses) */ {
 public:
  RlweMembershipResponses();
  virtual ~RlweMembershipResponses();

  RlweMembershipResponses(const RlweMembershipResponses& from);
  RlweMembershipResponses(RlweMembershipResponses&& from) noexcept
    : RlweMembershipResponses() {
    *this = ::std::move(from);
  }

  inline RlweMembershipResponses& operator=(const RlweMembershipResponses& from) {
    CopyFrom(from);
    return *this;
  }
  inline RlweMembershipResponses& operator=(RlweMembershipResponses&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const RlweMembershipResponses& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RlweMembershipResponses* internal_default_instance() {
    return reinterpret_cast<const RlweMembershipResponses*>(
               &_RlweMembershipResponses_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(RlweMembershipResponses& a, RlweMembershipResponses& b) {
    a.Swap(&b);
  }
  inline void Swap(RlweMembershipResponses* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RlweMembershipResponses* New() const final {
    return CreateMaybeMessage<RlweMembershipResponses>(nullptr);
  }

  RlweMembershipResponses* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RlweMembershipResponses>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const RlweMembershipResponses& from);
  void MergeFrom(const RlweMembershipResponses& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RlweMembershipResponses* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "private_membership.rlwe.RlweMembershipResponses";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef RlweMembershipResponses_MembershipResponseEntry MembershipResponseEntry;

  // accessors -------------------------------------------------------

  enum : int {
    kMembershipResponsesFieldNumber = 1,
  };
  // repeated .private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry membership_responses = 1;
  int membership_responses_size() const;
  private:
  int _internal_membership_responses_size() const;
  public:
  void clear_membership_responses();
  ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry* mutable_membership_responses(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry >*
      mutable_membership_responses();
  private:
  const ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry& _internal_membership_responses(int index) const;
  ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry* _internal_add_membership_responses();
  public:
  const ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry& membership_responses(int index) const;
  ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry* add_membership_responses();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry >&
      membership_responses() const;

  // @@protoc_insertion_point(class_scope:private_membership.rlwe.RlweMembershipResponses)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry > membership_responses_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_private_5fmembership_5frlwe_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// PrivateMembershipRlweOprfRequest

// repeated bytes encrypted_ids = 1;
inline int PrivateMembershipRlweOprfRequest::_internal_encrypted_ids_size() const {
  return encrypted_ids_.size();
}
inline int PrivateMembershipRlweOprfRequest::encrypted_ids_size() const {
  return _internal_encrypted_ids_size();
}
inline void PrivateMembershipRlweOprfRequest::clear_encrypted_ids() {
  encrypted_ids_.Clear();
}
inline std::string* PrivateMembershipRlweOprfRequest::add_encrypted_ids() {
  // @@protoc_insertion_point(field_add_mutable:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
  return _internal_add_encrypted_ids();
}
inline const std::string& PrivateMembershipRlweOprfRequest::_internal_encrypted_ids(int index) const {
  return encrypted_ids_.Get(index);
}
inline const std::string& PrivateMembershipRlweOprfRequest::encrypted_ids(int index) const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
  return _internal_encrypted_ids(index);
}
inline std::string* PrivateMembershipRlweOprfRequest::mutable_encrypted_ids(int index) {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
  return encrypted_ids_.Mutable(index);
}
inline void PrivateMembershipRlweOprfRequest::set_encrypted_ids(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
  encrypted_ids_.Mutable(index)->assign(value);
}
inline void PrivateMembershipRlweOprfRequest::set_encrypted_ids(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
  encrypted_ids_.Mutable(index)->assign(std::move(value));
}
inline void PrivateMembershipRlweOprfRequest::set_encrypted_ids(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  encrypted_ids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
}
inline void PrivateMembershipRlweOprfRequest::set_encrypted_ids(int index, const void* value, size_t size) {
  encrypted_ids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
}
inline std::string* PrivateMembershipRlweOprfRequest::_internal_add_encrypted_ids() {
  return encrypted_ids_.Add();
}
inline void PrivateMembershipRlweOprfRequest::add_encrypted_ids(const std::string& value) {
  encrypted_ids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
}
inline void PrivateMembershipRlweOprfRequest::add_encrypted_ids(std::string&& value) {
  encrypted_ids_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
}
inline void PrivateMembershipRlweOprfRequest::add_encrypted_ids(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  encrypted_ids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
}
inline void PrivateMembershipRlweOprfRequest::add_encrypted_ids(const void* value, size_t size) {
  encrypted_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
PrivateMembershipRlweOprfRequest::encrypted_ids() const {
  // @@protoc_insertion_point(field_list:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
  return encrypted_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
PrivateMembershipRlweOprfRequest::mutable_encrypted_ids() {
  // @@protoc_insertion_point(field_mutable_list:private_membership.rlwe.PrivateMembershipRlweOprfRequest.encrypted_ids)
  return &encrypted_ids_;
}

// .private_membership.rlwe.RlweUseCase use_case = 2;
inline void PrivateMembershipRlweOprfRequest::clear_use_case() {
  use_case_ = 0;
}
inline ::private_membership::rlwe::RlweUseCase PrivateMembershipRlweOprfRequest::_internal_use_case() const {
  return static_cast< ::private_membership::rlwe::RlweUseCase >(use_case_);
}
inline ::private_membership::rlwe::RlweUseCase PrivateMembershipRlweOprfRequest::use_case() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweOprfRequest.use_case)
  return _internal_use_case();
}
inline void PrivateMembershipRlweOprfRequest::_internal_set_use_case(::private_membership::rlwe::RlweUseCase value) {
  
  use_case_ = value;
}
inline void PrivateMembershipRlweOprfRequest::set_use_case(::private_membership::rlwe::RlweUseCase value) {
  _internal_set_use_case(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PrivateMembershipRlweOprfRequest.use_case)
}

// -------------------------------------------------------------------

// PrivateMembershipRlweOprfResponse

// repeated .private_membership.DoublyEncryptedId doubly_encrypted_ids = 1;
inline int PrivateMembershipRlweOprfResponse::_internal_doubly_encrypted_ids_size() const {
  return doubly_encrypted_ids_.size();
}
inline int PrivateMembershipRlweOprfResponse::doubly_encrypted_ids_size() const {
  return _internal_doubly_encrypted_ids_size();
}
inline ::private_membership::DoublyEncryptedId* PrivateMembershipRlweOprfResponse::mutable_doubly_encrypted_ids(int index) {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlweOprfResponse.doubly_encrypted_ids)
  return doubly_encrypted_ids_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::DoublyEncryptedId >*
PrivateMembershipRlweOprfResponse::mutable_doubly_encrypted_ids() {
  // @@protoc_insertion_point(field_mutable_list:private_membership.rlwe.PrivateMembershipRlweOprfResponse.doubly_encrypted_ids)
  return &doubly_encrypted_ids_;
}
inline const ::private_membership::DoublyEncryptedId& PrivateMembershipRlweOprfResponse::_internal_doubly_encrypted_ids(int index) const {
  return doubly_encrypted_ids_.Get(index);
}
inline const ::private_membership::DoublyEncryptedId& PrivateMembershipRlweOprfResponse::doubly_encrypted_ids(int index) const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweOprfResponse.doubly_encrypted_ids)
  return _internal_doubly_encrypted_ids(index);
}
inline ::private_membership::DoublyEncryptedId* PrivateMembershipRlweOprfResponse::_internal_add_doubly_encrypted_ids() {
  return doubly_encrypted_ids_.Add();
}
inline ::private_membership::DoublyEncryptedId* PrivateMembershipRlweOprfResponse::add_doubly_encrypted_ids() {
  // @@protoc_insertion_point(field_add:private_membership.rlwe.PrivateMembershipRlweOprfResponse.doubly_encrypted_ids)
  return _internal_add_doubly_encrypted_ids();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::DoublyEncryptedId >&
PrivateMembershipRlweOprfResponse::doubly_encrypted_ids() const {
  // @@protoc_insertion_point(field_list:private_membership.rlwe.PrivateMembershipRlweOprfResponse.doubly_encrypted_ids)
  return doubly_encrypted_ids_;
}

// .private_membership.rlwe.HashedBucketsParameters hashed_buckets_parameters = 2;
inline bool PrivateMembershipRlweOprfResponse::_internal_has_hashed_buckets_parameters() const {
  return this != internal_default_instance() && hashed_buckets_parameters_ != nullptr;
}
inline bool PrivateMembershipRlweOprfResponse::has_hashed_buckets_parameters() const {
  return _internal_has_hashed_buckets_parameters();
}
inline void PrivateMembershipRlweOprfResponse::clear_hashed_buckets_parameters() {
  if (GetArenaNoVirtual() == nullptr && hashed_buckets_parameters_ != nullptr) {
    delete hashed_buckets_parameters_;
  }
  hashed_buckets_parameters_ = nullptr;
}
inline const ::private_membership::rlwe::HashedBucketsParameters& PrivateMembershipRlweOprfResponse::_internal_hashed_buckets_parameters() const {
  const ::private_membership::rlwe::HashedBucketsParameters* p = hashed_buckets_parameters_;
  return p != nullptr ? *p : *reinterpret_cast<const ::private_membership::rlwe::HashedBucketsParameters*>(
      &::private_membership::rlwe::_HashedBucketsParameters_default_instance_);
}
inline const ::private_membership::rlwe::HashedBucketsParameters& PrivateMembershipRlweOprfResponse::hashed_buckets_parameters() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweOprfResponse.hashed_buckets_parameters)
  return _internal_hashed_buckets_parameters();
}
inline ::private_membership::rlwe::HashedBucketsParameters* PrivateMembershipRlweOprfResponse::release_hashed_buckets_parameters() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.PrivateMembershipRlweOprfResponse.hashed_buckets_parameters)
  
  ::private_membership::rlwe::HashedBucketsParameters* temp = hashed_buckets_parameters_;
  hashed_buckets_parameters_ = nullptr;
  return temp;
}
inline ::private_membership::rlwe::HashedBucketsParameters* PrivateMembershipRlweOprfResponse::_internal_mutable_hashed_buckets_parameters() {
  
  if (hashed_buckets_parameters_ == nullptr) {
    auto* p = CreateMaybeMessage<::private_membership::rlwe::HashedBucketsParameters>(GetArenaNoVirtual());
    hashed_buckets_parameters_ = p;
  }
  return hashed_buckets_parameters_;
}
inline ::private_membership::rlwe::HashedBucketsParameters* PrivateMembershipRlweOprfResponse::mutable_hashed_buckets_parameters() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlweOprfResponse.hashed_buckets_parameters)
  return _internal_mutable_hashed_buckets_parameters();
}
inline void PrivateMembershipRlweOprfResponse::set_allocated_hashed_buckets_parameters(::private_membership::rlwe::HashedBucketsParameters* hashed_buckets_parameters) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete hashed_buckets_parameters_;
  }
  if (hashed_buckets_parameters) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      hashed_buckets_parameters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hashed_buckets_parameters, submessage_arena);
    }
    
  } else {
    
  }
  hashed_buckets_parameters_ = hashed_buckets_parameters;
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.PrivateMembershipRlweOprfResponse.hashed_buckets_parameters)
}

// .private_membership.rlwe.EncryptedBucketsParameters encrypted_buckets_parameters = 3;
inline bool PrivateMembershipRlweOprfResponse::_internal_has_encrypted_buckets_parameters() const {
  return this != internal_default_instance() && encrypted_buckets_parameters_ != nullptr;
}
inline bool PrivateMembershipRlweOprfResponse::has_encrypted_buckets_parameters() const {
  return _internal_has_encrypted_buckets_parameters();
}
inline void PrivateMembershipRlweOprfResponse::clear_encrypted_buckets_parameters() {
  if (GetArenaNoVirtual() == nullptr && encrypted_buckets_parameters_ != nullptr) {
    delete encrypted_buckets_parameters_;
  }
  encrypted_buckets_parameters_ = nullptr;
}
inline const ::private_membership::rlwe::EncryptedBucketsParameters& PrivateMembershipRlweOprfResponse::_internal_encrypted_buckets_parameters() const {
  const ::private_membership::rlwe::EncryptedBucketsParameters* p = encrypted_buckets_parameters_;
  return p != nullptr ? *p : *reinterpret_cast<const ::private_membership::rlwe::EncryptedBucketsParameters*>(
      &::private_membership::rlwe::_EncryptedBucketsParameters_default_instance_);
}
inline const ::private_membership::rlwe::EncryptedBucketsParameters& PrivateMembershipRlweOprfResponse::encrypted_buckets_parameters() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweOprfResponse.encrypted_buckets_parameters)
  return _internal_encrypted_buckets_parameters();
}
inline ::private_membership::rlwe::EncryptedBucketsParameters* PrivateMembershipRlweOprfResponse::release_encrypted_buckets_parameters() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.PrivateMembershipRlweOprfResponse.encrypted_buckets_parameters)
  
  ::private_membership::rlwe::EncryptedBucketsParameters* temp = encrypted_buckets_parameters_;
  encrypted_buckets_parameters_ = nullptr;
  return temp;
}
inline ::private_membership::rlwe::EncryptedBucketsParameters* PrivateMembershipRlweOprfResponse::_internal_mutable_encrypted_buckets_parameters() {
  
  if (encrypted_buckets_parameters_ == nullptr) {
    auto* p = CreateMaybeMessage<::private_membership::rlwe::EncryptedBucketsParameters>(GetArenaNoVirtual());
    encrypted_buckets_parameters_ = p;
  }
  return encrypted_buckets_parameters_;
}
inline ::private_membership::rlwe::EncryptedBucketsParameters* PrivateMembershipRlweOprfResponse::mutable_encrypted_buckets_parameters() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlweOprfResponse.encrypted_buckets_parameters)
  return _internal_mutable_encrypted_buckets_parameters();
}
inline void PrivateMembershipRlweOprfResponse::set_allocated_encrypted_buckets_parameters(::private_membership::rlwe::EncryptedBucketsParameters* encrypted_buckets_parameters) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete encrypted_buckets_parameters_;
  }
  if (encrypted_buckets_parameters) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      encrypted_buckets_parameters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, encrypted_buckets_parameters, submessage_arena);
    }
    
  } else {
    
  }
  encrypted_buckets_parameters_ = encrypted_buckets_parameters;
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.PrivateMembershipRlweOprfResponse.encrypted_buckets_parameters)
}

// .private_membership.rlwe.RlweParameters rlwe_parameters = 4;
inline bool PrivateMembershipRlweOprfResponse::_internal_has_rlwe_parameters() const {
  return this != internal_default_instance() && rlwe_parameters_ != nullptr;
}
inline bool PrivateMembershipRlweOprfResponse::has_rlwe_parameters() const {
  return _internal_has_rlwe_parameters();
}
inline void PrivateMembershipRlweOprfResponse::clear_rlwe_parameters() {
  if (GetArenaNoVirtual() == nullptr && rlwe_parameters_ != nullptr) {
    delete rlwe_parameters_;
  }
  rlwe_parameters_ = nullptr;
}
inline const ::private_membership::rlwe::RlweParameters& PrivateMembershipRlweOprfResponse::_internal_rlwe_parameters() const {
  const ::private_membership::rlwe::RlweParameters* p = rlwe_parameters_;
  return p != nullptr ? *p : *reinterpret_cast<const ::private_membership::rlwe::RlweParameters*>(
      &::private_membership::rlwe::_RlweParameters_default_instance_);
}
inline const ::private_membership::rlwe::RlweParameters& PrivateMembershipRlweOprfResponse::rlwe_parameters() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweOprfResponse.rlwe_parameters)
  return _internal_rlwe_parameters();
}
inline ::private_membership::rlwe::RlweParameters* PrivateMembershipRlweOprfResponse::release_rlwe_parameters() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.PrivateMembershipRlweOprfResponse.rlwe_parameters)
  
  ::private_membership::rlwe::RlweParameters* temp = rlwe_parameters_;
  rlwe_parameters_ = nullptr;
  return temp;
}
inline ::private_membership::rlwe::RlweParameters* PrivateMembershipRlweOprfResponse::_internal_mutable_rlwe_parameters() {
  
  if (rlwe_parameters_ == nullptr) {
    auto* p = CreateMaybeMessage<::private_membership::rlwe::RlweParameters>(GetArenaNoVirtual());
    rlwe_parameters_ = p;
  }
  return rlwe_parameters_;
}
inline ::private_membership::rlwe::RlweParameters* PrivateMembershipRlweOprfResponse::mutable_rlwe_parameters() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlweOprfResponse.rlwe_parameters)
  return _internal_mutable_rlwe_parameters();
}
inline void PrivateMembershipRlweOprfResponse::set_allocated_rlwe_parameters(::private_membership::rlwe::RlweParameters* rlwe_parameters) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete rlwe_parameters_;
  }
  if (rlwe_parameters) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      rlwe_parameters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rlwe_parameters, submessage_arena);
    }
    
  } else {
    
  }
  rlwe_parameters_ = rlwe_parameters;
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.PrivateMembershipRlweOprfResponse.rlwe_parameters)
}

// int64 key_version = 5;
inline void PrivateMembershipRlweOprfResponse::clear_key_version() {
  key_version_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 PrivateMembershipRlweOprfResponse::_internal_key_version() const {
  return key_version_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 PrivateMembershipRlweOprfResponse::key_version() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweOprfResponse.key_version)
  return _internal_key_version();
}
inline void PrivateMembershipRlweOprfResponse::_internal_set_key_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  key_version_ = value;
}
inline void PrivateMembershipRlweOprfResponse::set_key_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_key_version(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PrivateMembershipRlweOprfResponse.key_version)
}

// -------------------------------------------------------------------

// PrivateMembershipRlweQueryRequest

// repeated .private_membership.rlwe.PrivateMembershipRlweQuery queries = 1;
inline int PrivateMembershipRlweQueryRequest::_internal_queries_size() const {
  return queries_.size();
}
inline int PrivateMembershipRlweQueryRequest::queries_size() const {
  return _internal_queries_size();
}
inline void PrivateMembershipRlweQueryRequest::clear_queries() {
  queries_.Clear();
}
inline ::private_membership::rlwe::PrivateMembershipRlweQuery* PrivateMembershipRlweQueryRequest::mutable_queries(int index) {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlweQueryRequest.queries)
  return queries_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::PrivateMembershipRlweQuery >*
PrivateMembershipRlweQueryRequest::mutable_queries() {
  // @@protoc_insertion_point(field_mutable_list:private_membership.rlwe.PrivateMembershipRlweQueryRequest.queries)
  return &queries_;
}
inline const ::private_membership::rlwe::PrivateMembershipRlweQuery& PrivateMembershipRlweQueryRequest::_internal_queries(int index) const {
  return queries_.Get(index);
}
inline const ::private_membership::rlwe::PrivateMembershipRlweQuery& PrivateMembershipRlweQueryRequest::queries(int index) const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweQueryRequest.queries)
  return _internal_queries(index);
}
inline ::private_membership::rlwe::PrivateMembershipRlweQuery* PrivateMembershipRlweQueryRequest::_internal_add_queries() {
  return queries_.Add();
}
inline ::private_membership::rlwe::PrivateMembershipRlweQuery* PrivateMembershipRlweQueryRequest::add_queries() {
  // @@protoc_insertion_point(field_add:private_membership.rlwe.PrivateMembershipRlweQueryRequest.queries)
  return _internal_add_queries();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::PrivateMembershipRlweQuery >&
PrivateMembershipRlweQueryRequest::queries() const {
  // @@protoc_insertion_point(field_list:private_membership.rlwe.PrivateMembershipRlweQueryRequest.queries)
  return queries_;
}

// .private_membership.rlwe.RlweUseCase use_case = 2;
inline void PrivateMembershipRlweQueryRequest::clear_use_case() {
  use_case_ = 0;
}
inline ::private_membership::rlwe::RlweUseCase PrivateMembershipRlweQueryRequest::_internal_use_case() const {
  return static_cast< ::private_membership::rlwe::RlweUseCase >(use_case_);
}
inline ::private_membership::rlwe::RlweUseCase PrivateMembershipRlweQueryRequest::use_case() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweQueryRequest.use_case)
  return _internal_use_case();
}
inline void PrivateMembershipRlweQueryRequest::_internal_set_use_case(::private_membership::rlwe::RlweUseCase value) {
  
  use_case_ = value;
}
inline void PrivateMembershipRlweQueryRequest::set_use_case(::private_membership::rlwe::RlweUseCase value) {
  _internal_set_use_case(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PrivateMembershipRlweQueryRequest.use_case)
}

// int64 key_version = 3;
inline void PrivateMembershipRlweQueryRequest::clear_key_version() {
  key_version_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 PrivateMembershipRlweQueryRequest::_internal_key_version() const {
  return key_version_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 PrivateMembershipRlweQueryRequest::key_version() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweQueryRequest.key_version)
  return _internal_key_version();
}
inline void PrivateMembershipRlweQueryRequest::_internal_set_key_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  key_version_ = value;
}
inline void PrivateMembershipRlweQueryRequest::set_key_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_key_version(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PrivateMembershipRlweQueryRequest.key_version)
}

// -------------------------------------------------------------------

// PrivateMembershipRlweQueryResponse

// repeated .private_membership.rlwe.PrivateMembershipRlwePirResponse pir_responses = 1;
inline int PrivateMembershipRlweQueryResponse::_internal_pir_responses_size() const {
  return pir_responses_.size();
}
inline int PrivateMembershipRlweQueryResponse::pir_responses_size() const {
  return _internal_pir_responses_size();
}
inline void PrivateMembershipRlweQueryResponse::clear_pir_responses() {
  pir_responses_.Clear();
}
inline ::private_membership::rlwe::PrivateMembershipRlwePirResponse* PrivateMembershipRlweQueryResponse::mutable_pir_responses(int index) {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlweQueryResponse.pir_responses)
  return pir_responses_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::PrivateMembershipRlwePirResponse >*
PrivateMembershipRlweQueryResponse::mutable_pir_responses() {
  // @@protoc_insertion_point(field_mutable_list:private_membership.rlwe.PrivateMembershipRlweQueryResponse.pir_responses)
  return &pir_responses_;
}
inline const ::private_membership::rlwe::PrivateMembershipRlwePirResponse& PrivateMembershipRlweQueryResponse::_internal_pir_responses(int index) const {
  return pir_responses_.Get(index);
}
inline const ::private_membership::rlwe::PrivateMembershipRlwePirResponse& PrivateMembershipRlweQueryResponse::pir_responses(int index) const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweQueryResponse.pir_responses)
  return _internal_pir_responses(index);
}
inline ::private_membership::rlwe::PrivateMembershipRlwePirResponse* PrivateMembershipRlweQueryResponse::_internal_add_pir_responses() {
  return pir_responses_.Add();
}
inline ::private_membership::rlwe::PrivateMembershipRlwePirResponse* PrivateMembershipRlweQueryResponse::add_pir_responses() {
  // @@protoc_insertion_point(field_add:private_membership.rlwe.PrivateMembershipRlweQueryResponse.pir_responses)
  return _internal_add_pir_responses();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::PrivateMembershipRlwePirResponse >&
PrivateMembershipRlweQueryResponse::pir_responses() const {
  // @@protoc_insertion_point(field_list:private_membership.rlwe.PrivateMembershipRlweQueryResponse.pir_responses)
  return pir_responses_;
}

// -------------------------------------------------------------------

// RlwePlaintextId

// string non_sensitive_id = 1;
inline void RlwePlaintextId::clear_non_sensitive_id() {
  non_sensitive_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& RlwePlaintextId::non_sensitive_id() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.RlwePlaintextId.non_sensitive_id)
  return _internal_non_sensitive_id();
}
inline void RlwePlaintextId::set_non_sensitive_id(const std::string& value) {
  _internal_set_non_sensitive_id(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.RlwePlaintextId.non_sensitive_id)
}
inline std::string* RlwePlaintextId::mutable_non_sensitive_id() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.RlwePlaintextId.non_sensitive_id)
  return _internal_mutable_non_sensitive_id();
}
inline const std::string& RlwePlaintextId::_internal_non_sensitive_id() const {
  return non_sensitive_id_.GetNoArena();
}
inline void RlwePlaintextId::_internal_set_non_sensitive_id(const std::string& value) {
  
  non_sensitive_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void RlwePlaintextId::set_non_sensitive_id(std::string&& value) {
  
  non_sensitive_id_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:private_membership.rlwe.RlwePlaintextId.non_sensitive_id)
}
inline void RlwePlaintextId::set_non_sensitive_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  non_sensitive_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:private_membership.rlwe.RlwePlaintextId.non_sensitive_id)
}
inline void RlwePlaintextId::set_non_sensitive_id(const char* value, size_t size) {
  
  non_sensitive_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:private_membership.rlwe.RlwePlaintextId.non_sensitive_id)
}
inline std::string* RlwePlaintextId::_internal_mutable_non_sensitive_id() {
  
  return non_sensitive_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* RlwePlaintextId::release_non_sensitive_id() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.RlwePlaintextId.non_sensitive_id)
  
  return non_sensitive_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void RlwePlaintextId::set_allocated_non_sensitive_id(std::string* non_sensitive_id) {
  if (non_sensitive_id != nullptr) {
    
  } else {
    
  }
  non_sensitive_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), non_sensitive_id);
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.RlwePlaintextId.non_sensitive_id)
}

// string sensitive_id = 2;
inline void RlwePlaintextId::clear_sensitive_id() {
  sensitive_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& RlwePlaintextId::sensitive_id() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.RlwePlaintextId.sensitive_id)
  return _internal_sensitive_id();
}
inline void RlwePlaintextId::set_sensitive_id(const std::string& value) {
  _internal_set_sensitive_id(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.RlwePlaintextId.sensitive_id)
}
inline std::string* RlwePlaintextId::mutable_sensitive_id() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.RlwePlaintextId.sensitive_id)
  return _internal_mutable_sensitive_id();
}
inline const std::string& RlwePlaintextId::_internal_sensitive_id() const {
  return sensitive_id_.GetNoArena();
}
inline void RlwePlaintextId::_internal_set_sensitive_id(const std::string& value) {
  
  sensitive_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void RlwePlaintextId::set_sensitive_id(std::string&& value) {
  
  sensitive_id_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:private_membership.rlwe.RlwePlaintextId.sensitive_id)
}
inline void RlwePlaintextId::set_sensitive_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  sensitive_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:private_membership.rlwe.RlwePlaintextId.sensitive_id)
}
inline void RlwePlaintextId::set_sensitive_id(const char* value, size_t size) {
  
  sensitive_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:private_membership.rlwe.RlwePlaintextId.sensitive_id)
}
inline std::string* RlwePlaintextId::_internal_mutable_sensitive_id() {
  
  return sensitive_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* RlwePlaintextId::release_sensitive_id() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.RlwePlaintextId.sensitive_id)
  
  return sensitive_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void RlwePlaintextId::set_allocated_sensitive_id(std::string* sensitive_id) {
  if (sensitive_id != nullptr) {
    
  } else {
    
  }
  sensitive_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sensitive_id);
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.RlwePlaintextId.sensitive_id)
}

// -------------------------------------------------------------------

// HashedBucketsParameters

// int32 hashed_bucket_id_length = 1;
inline void HashedBucketsParameters::clear_hashed_bucket_id_length() {
  hashed_bucket_id_length_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 HashedBucketsParameters::_internal_hashed_bucket_id_length() const {
  return hashed_bucket_id_length_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 HashedBucketsParameters::hashed_bucket_id_length() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.HashedBucketsParameters.hashed_bucket_id_length)
  return _internal_hashed_bucket_id_length();
}
inline void HashedBucketsParameters::_internal_set_hashed_bucket_id_length(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  hashed_bucket_id_length_ = value;
}
inline void HashedBucketsParameters::set_hashed_bucket_id_length(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_hashed_bucket_id_length(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.HashedBucketsParameters.hashed_bucket_id_length)
}

// .private_membership.HashType non_sensitive_id_hash_type = 2;
inline void HashedBucketsParameters::clear_non_sensitive_id_hash_type() {
  non_sensitive_id_hash_type_ = 0;
}
inline ::private_membership::HashType HashedBucketsParameters::_internal_non_sensitive_id_hash_type() const {
  return static_cast< ::private_membership::HashType >(non_sensitive_id_hash_type_);
}
inline ::private_membership::HashType HashedBucketsParameters::non_sensitive_id_hash_type() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.HashedBucketsParameters.non_sensitive_id_hash_type)
  return _internal_non_sensitive_id_hash_type();
}
inline void HashedBucketsParameters::_internal_set_non_sensitive_id_hash_type(::private_membership::HashType value) {
  
  non_sensitive_id_hash_type_ = value;
}
inline void HashedBucketsParameters::set_non_sensitive_id_hash_type(::private_membership::HashType value) {
  _internal_set_non_sensitive_id_hash_type(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.HashedBucketsParameters.non_sensitive_id_hash_type)
}

// -------------------------------------------------------------------

// EncryptedBucketsParameters

// int32 encrypted_bucket_id_length = 1;
inline void EncryptedBucketsParameters::clear_encrypted_bucket_id_length() {
  encrypted_bucket_id_length_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 EncryptedBucketsParameters::_internal_encrypted_bucket_id_length() const {
  return encrypted_bucket_id_length_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 EncryptedBucketsParameters::encrypted_bucket_id_length() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.EncryptedBucketsParameters.encrypted_bucket_id_length)
  return _internal_encrypted_bucket_id_length();
}
inline void EncryptedBucketsParameters::_internal_set_encrypted_bucket_id_length(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  encrypted_bucket_id_length_ = value;
}
inline void EncryptedBucketsParameters::set_encrypted_bucket_id_length(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_encrypted_bucket_id_length(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.EncryptedBucketsParameters.encrypted_bucket_id_length)
}

// .private_membership.EncryptedBucketHashType sensitive_id_hash_type = 2;
inline void EncryptedBucketsParameters::clear_sensitive_id_hash_type() {
  sensitive_id_hash_type_ = 0;
}
inline ::private_membership::EncryptedBucketHashType EncryptedBucketsParameters::_internal_sensitive_id_hash_type() const {
  return static_cast< ::private_membership::EncryptedBucketHashType >(sensitive_id_hash_type_);
}
inline ::private_membership::EncryptedBucketHashType EncryptedBucketsParameters::sensitive_id_hash_type() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.EncryptedBucketsParameters.sensitive_id_hash_type)
  return _internal_sensitive_id_hash_type();
}
inline void EncryptedBucketsParameters::_internal_set_sensitive_id_hash_type(::private_membership::EncryptedBucketHashType value) {
  
  sensitive_id_hash_type_ = value;
}
inline void EncryptedBucketsParameters::set_sensitive_id_hash_type(::private_membership::EncryptedBucketHashType value) {
  _internal_set_sensitive_id_hash_type(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.EncryptedBucketsParameters.sensitive_id_hash_type)
}

// -------------------------------------------------------------------

// RlweParameters

// repeated .private_membership.rlwe.Uint128 modulus = 1;
inline int RlweParameters::_internal_modulus_size() const {
  return modulus_.size();
}
inline int RlweParameters::modulus_size() const {
  return _internal_modulus_size();
}
inline void RlweParameters::clear_modulus() {
  modulus_.Clear();
}
inline ::private_membership::rlwe::Uint128* RlweParameters::mutable_modulus(int index) {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.RlweParameters.modulus)
  return modulus_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::Uint128 >*
RlweParameters::mutable_modulus() {
  // @@protoc_insertion_point(field_mutable_list:private_membership.rlwe.RlweParameters.modulus)
  return &modulus_;
}
inline const ::private_membership::rlwe::Uint128& RlweParameters::_internal_modulus(int index) const {
  return modulus_.Get(index);
}
inline const ::private_membership::rlwe::Uint128& RlweParameters::modulus(int index) const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.RlweParameters.modulus)
  return _internal_modulus(index);
}
inline ::private_membership::rlwe::Uint128* RlweParameters::_internal_add_modulus() {
  return modulus_.Add();
}
inline ::private_membership::rlwe::Uint128* RlweParameters::add_modulus() {
  // @@protoc_insertion_point(field_add:private_membership.rlwe.RlweParameters.modulus)
  return _internal_add_modulus();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::Uint128 >&
RlweParameters::modulus() const {
  // @@protoc_insertion_point(field_list:private_membership.rlwe.RlweParameters.modulus)
  return modulus_;
}

// int32 log_degree = 2;
inline void RlweParameters::clear_log_degree() {
  log_degree_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RlweParameters::_internal_log_degree() const {
  return log_degree_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RlweParameters::log_degree() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.RlweParameters.log_degree)
  return _internal_log_degree();
}
inline void RlweParameters::_internal_set_log_degree(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  log_degree_ = value;
}
inline void RlweParameters::set_log_degree(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_log_degree(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.RlweParameters.log_degree)
}

// int32 log_t = 3;
inline void RlweParameters::clear_log_t() {
  log_t_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RlweParameters::_internal_log_t() const {
  return log_t_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RlweParameters::log_t() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.RlweParameters.log_t)
  return _internal_log_t();
}
inline void RlweParameters::_internal_set_log_t(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  log_t_ = value;
}
inline void RlweParameters::set_log_t(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_log_t(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.RlweParameters.log_t)
}

// int32 variance = 4;
inline void RlweParameters::clear_variance() {
  variance_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RlweParameters::_internal_variance() const {
  return variance_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RlweParameters::variance() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.RlweParameters.variance)
  return _internal_variance();
}
inline void RlweParameters::_internal_set_variance(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  variance_ = value;
}
inline void RlweParameters::set_variance(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_variance(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.RlweParameters.variance)
}

// int32 levels_of_recursion = 5;
inline void RlweParameters::clear_levels_of_recursion() {
  levels_of_recursion_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RlweParameters::_internal_levels_of_recursion() const {
  return levels_of_recursion_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RlweParameters::levels_of_recursion() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.RlweParameters.levels_of_recursion)
  return _internal_levels_of_recursion();
}
inline void RlweParameters::_internal_set_levels_of_recursion(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  levels_of_recursion_ = value;
}
inline void RlweParameters::set_levels_of_recursion(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_levels_of_recursion(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.RlweParameters.levels_of_recursion)
}

// -------------------------------------------------------------------

// Uint128

// uint64 lo = 1;
inline void Uint128::clear_lo() {
  lo_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Uint128::_internal_lo() const {
  return lo_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Uint128::lo() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.Uint128.lo)
  return _internal_lo();
}
inline void Uint128::_internal_set_lo(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  lo_ = value;
}
inline void Uint128::set_lo(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_lo(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.Uint128.lo)
}

// uint64 hi = 2;
inline void Uint128::clear_hi() {
  hi_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Uint128::_internal_hi() const {
  return hi_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Uint128::hi() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.Uint128.hi)
  return _internal_hi();
}
inline void Uint128::_internal_set_hi(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  hi_ = value;
}
inline void Uint128::set_hi(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_hi(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.Uint128.hi)
}

// -------------------------------------------------------------------

// PrivateMembershipRlweQuery_HashedBucketId

// bytes hashed_bucket_id = 1;
inline void PrivateMembershipRlweQuery_HashedBucketId::clear_hashed_bucket_id() {
  hashed_bucket_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PrivateMembershipRlweQuery_HashedBucketId::hashed_bucket_id() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId.hashed_bucket_id)
  return _internal_hashed_bucket_id();
}
inline void PrivateMembershipRlweQuery_HashedBucketId::set_hashed_bucket_id(const std::string& value) {
  _internal_set_hashed_bucket_id(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId.hashed_bucket_id)
}
inline std::string* PrivateMembershipRlweQuery_HashedBucketId::mutable_hashed_bucket_id() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId.hashed_bucket_id)
  return _internal_mutable_hashed_bucket_id();
}
inline const std::string& PrivateMembershipRlweQuery_HashedBucketId::_internal_hashed_bucket_id() const {
  return hashed_bucket_id_.GetNoArena();
}
inline void PrivateMembershipRlweQuery_HashedBucketId::_internal_set_hashed_bucket_id(const std::string& value) {
  
  hashed_bucket_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void PrivateMembershipRlweQuery_HashedBucketId::set_hashed_bucket_id(std::string&& value) {
  
  hashed_bucket_id_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId.hashed_bucket_id)
}
inline void PrivateMembershipRlweQuery_HashedBucketId::set_hashed_bucket_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  hashed_bucket_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId.hashed_bucket_id)
}
inline void PrivateMembershipRlweQuery_HashedBucketId::set_hashed_bucket_id(const void* value, size_t size) {
  
  hashed_bucket_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId.hashed_bucket_id)
}
inline std::string* PrivateMembershipRlweQuery_HashedBucketId::_internal_mutable_hashed_bucket_id() {
  
  return hashed_bucket_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PrivateMembershipRlweQuery_HashedBucketId::release_hashed_bucket_id() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId.hashed_bucket_id)
  
  return hashed_bucket_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PrivateMembershipRlweQuery_HashedBucketId::set_allocated_hashed_bucket_id(std::string* hashed_bucket_id) {
  if (hashed_bucket_id != nullptr) {
    
  } else {
    
  }
  hashed_bucket_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), hashed_bucket_id);
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId.hashed_bucket_id)
}

// int32 bit_length = 2;
inline void PrivateMembershipRlweQuery_HashedBucketId::clear_bit_length() {
  bit_length_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PrivateMembershipRlweQuery_HashedBucketId::_internal_bit_length() const {
  return bit_length_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PrivateMembershipRlweQuery_HashedBucketId::bit_length() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId.bit_length)
  return _internal_bit_length();
}
inline void PrivateMembershipRlweQuery_HashedBucketId::_internal_set_bit_length(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  bit_length_ = value;
}
inline void PrivateMembershipRlweQuery_HashedBucketId::set_bit_length(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_bit_length(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId.bit_length)
}

// -------------------------------------------------------------------

// PrivateMembershipRlweQuery

// bytes queried_encrypted_id = 1;
inline void PrivateMembershipRlweQuery::clear_queried_encrypted_id() {
  queried_encrypted_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PrivateMembershipRlweQuery::queried_encrypted_id() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweQuery.queried_encrypted_id)
  return _internal_queried_encrypted_id();
}
inline void PrivateMembershipRlweQuery::set_queried_encrypted_id(const std::string& value) {
  _internal_set_queried_encrypted_id(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PrivateMembershipRlweQuery.queried_encrypted_id)
}
inline std::string* PrivateMembershipRlweQuery::mutable_queried_encrypted_id() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlweQuery.queried_encrypted_id)
  return _internal_mutable_queried_encrypted_id();
}
inline const std::string& PrivateMembershipRlweQuery::_internal_queried_encrypted_id() const {
  return queried_encrypted_id_.GetNoArena();
}
inline void PrivateMembershipRlweQuery::_internal_set_queried_encrypted_id(const std::string& value) {
  
  queried_encrypted_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void PrivateMembershipRlweQuery::set_queried_encrypted_id(std::string&& value) {
  
  queried_encrypted_id_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:private_membership.rlwe.PrivateMembershipRlweQuery.queried_encrypted_id)
}
inline void PrivateMembershipRlweQuery::set_queried_encrypted_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  queried_encrypted_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:private_membership.rlwe.PrivateMembershipRlweQuery.queried_encrypted_id)
}
inline void PrivateMembershipRlweQuery::set_queried_encrypted_id(const void* value, size_t size) {
  
  queried_encrypted_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:private_membership.rlwe.PrivateMembershipRlweQuery.queried_encrypted_id)
}
inline std::string* PrivateMembershipRlweQuery::_internal_mutable_queried_encrypted_id() {
  
  return queried_encrypted_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PrivateMembershipRlweQuery::release_queried_encrypted_id() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.PrivateMembershipRlweQuery.queried_encrypted_id)
  
  return queried_encrypted_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PrivateMembershipRlweQuery::set_allocated_queried_encrypted_id(std::string* queried_encrypted_id) {
  if (queried_encrypted_id != nullptr) {
    
  } else {
    
  }
  queried_encrypted_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), queried_encrypted_id);
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.PrivateMembershipRlweQuery.queried_encrypted_id)
}

// .private_membership.rlwe.PirRequest pir_request = 2;
inline bool PrivateMembershipRlweQuery::_internal_has_pir_request() const {
  return this != internal_default_instance() && pir_request_ != nullptr;
}
inline bool PrivateMembershipRlweQuery::has_pir_request() const {
  return _internal_has_pir_request();
}
inline void PrivateMembershipRlweQuery::clear_pir_request() {
  if (GetArenaNoVirtual() == nullptr && pir_request_ != nullptr) {
    delete pir_request_;
  }
  pir_request_ = nullptr;
}
inline const ::private_membership::rlwe::PirRequest& PrivateMembershipRlweQuery::_internal_pir_request() const {
  const ::private_membership::rlwe::PirRequest* p = pir_request_;
  return p != nullptr ? *p : *reinterpret_cast<const ::private_membership::rlwe::PirRequest*>(
      &::private_membership::rlwe::_PirRequest_default_instance_);
}
inline const ::private_membership::rlwe::PirRequest& PrivateMembershipRlweQuery::pir_request() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweQuery.pir_request)
  return _internal_pir_request();
}
inline ::private_membership::rlwe::PirRequest* PrivateMembershipRlweQuery::release_pir_request() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.PrivateMembershipRlweQuery.pir_request)
  
  ::private_membership::rlwe::PirRequest* temp = pir_request_;
  pir_request_ = nullptr;
  return temp;
}
inline ::private_membership::rlwe::PirRequest* PrivateMembershipRlweQuery::_internal_mutable_pir_request() {
  
  if (pir_request_ == nullptr) {
    auto* p = CreateMaybeMessage<::private_membership::rlwe::PirRequest>(GetArenaNoVirtual());
    pir_request_ = p;
  }
  return pir_request_;
}
inline ::private_membership::rlwe::PirRequest* PrivateMembershipRlweQuery::mutable_pir_request() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlweQuery.pir_request)
  return _internal_mutable_pir_request();
}
inline void PrivateMembershipRlweQuery::set_allocated_pir_request(::private_membership::rlwe::PirRequest* pir_request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete pir_request_;
  }
  if (pir_request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      pir_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pir_request, submessage_arena);
    }
    
  } else {
    
  }
  pir_request_ = pir_request;
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.PrivateMembershipRlweQuery.pir_request)
}

// .private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId hashed_bucket_id = 3;
inline bool PrivateMembershipRlweQuery::_internal_has_hashed_bucket_id() const {
  return this != internal_default_instance() && hashed_bucket_id_ != nullptr;
}
inline bool PrivateMembershipRlweQuery::has_hashed_bucket_id() const {
  return _internal_has_hashed_bucket_id();
}
inline void PrivateMembershipRlweQuery::clear_hashed_bucket_id() {
  if (GetArenaNoVirtual() == nullptr && hashed_bucket_id_ != nullptr) {
    delete hashed_bucket_id_;
  }
  hashed_bucket_id_ = nullptr;
}
inline const ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId& PrivateMembershipRlweQuery::_internal_hashed_bucket_id() const {
  const ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* p = hashed_bucket_id_;
  return p != nullptr ? *p : *reinterpret_cast<const ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId*>(
      &::private_membership::rlwe::_PrivateMembershipRlweQuery_HashedBucketId_default_instance_);
}
inline const ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId& PrivateMembershipRlweQuery::hashed_bucket_id() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlweQuery.hashed_bucket_id)
  return _internal_hashed_bucket_id();
}
inline ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* PrivateMembershipRlweQuery::release_hashed_bucket_id() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.PrivateMembershipRlweQuery.hashed_bucket_id)
  
  ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* temp = hashed_bucket_id_;
  hashed_bucket_id_ = nullptr;
  return temp;
}
inline ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* PrivateMembershipRlweQuery::_internal_mutable_hashed_bucket_id() {
  
  if (hashed_bucket_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId>(GetArenaNoVirtual());
    hashed_bucket_id_ = p;
  }
  return hashed_bucket_id_;
}
inline ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* PrivateMembershipRlweQuery::mutable_hashed_bucket_id() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlweQuery.hashed_bucket_id)
  return _internal_mutable_hashed_bucket_id();
}
inline void PrivateMembershipRlweQuery::set_allocated_hashed_bucket_id(::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* hashed_bucket_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete hashed_bucket_id_;
  }
  if (hashed_bucket_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      hashed_bucket_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hashed_bucket_id, submessage_arena);
    }
    
  } else {
    
  }
  hashed_bucket_id_ = hashed_bucket_id;
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.PrivateMembershipRlweQuery.hashed_bucket_id)
}

// -------------------------------------------------------------------

// PrivateMembershipRlwePirResponse

// bytes queried_encrypted_id = 1;
inline void PrivateMembershipRlwePirResponse::clear_queried_encrypted_id() {
  queried_encrypted_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PrivateMembershipRlwePirResponse::queried_encrypted_id() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlwePirResponse.queried_encrypted_id)
  return _internal_queried_encrypted_id();
}
inline void PrivateMembershipRlwePirResponse::set_queried_encrypted_id(const std::string& value) {
  _internal_set_queried_encrypted_id(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PrivateMembershipRlwePirResponse.queried_encrypted_id)
}
inline std::string* PrivateMembershipRlwePirResponse::mutable_queried_encrypted_id() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlwePirResponse.queried_encrypted_id)
  return _internal_mutable_queried_encrypted_id();
}
inline const std::string& PrivateMembershipRlwePirResponse::_internal_queried_encrypted_id() const {
  return queried_encrypted_id_.GetNoArena();
}
inline void PrivateMembershipRlwePirResponse::_internal_set_queried_encrypted_id(const std::string& value) {
  
  queried_encrypted_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void PrivateMembershipRlwePirResponse::set_queried_encrypted_id(std::string&& value) {
  
  queried_encrypted_id_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:private_membership.rlwe.PrivateMembershipRlwePirResponse.queried_encrypted_id)
}
inline void PrivateMembershipRlwePirResponse::set_queried_encrypted_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  queried_encrypted_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:private_membership.rlwe.PrivateMembershipRlwePirResponse.queried_encrypted_id)
}
inline void PrivateMembershipRlwePirResponse::set_queried_encrypted_id(const void* value, size_t size) {
  
  queried_encrypted_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:private_membership.rlwe.PrivateMembershipRlwePirResponse.queried_encrypted_id)
}
inline std::string* PrivateMembershipRlwePirResponse::_internal_mutable_queried_encrypted_id() {
  
  return queried_encrypted_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PrivateMembershipRlwePirResponse::release_queried_encrypted_id() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.PrivateMembershipRlwePirResponse.queried_encrypted_id)
  
  return queried_encrypted_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PrivateMembershipRlwePirResponse::set_allocated_queried_encrypted_id(std::string* queried_encrypted_id) {
  if (queried_encrypted_id != nullptr) {
    
  } else {
    
  }
  queried_encrypted_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), queried_encrypted_id);
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.PrivateMembershipRlwePirResponse.queried_encrypted_id)
}

// .private_membership.rlwe.PirResponse pir_response = 2;
inline bool PrivateMembershipRlwePirResponse::_internal_has_pir_response() const {
  return this != internal_default_instance() && pir_response_ != nullptr;
}
inline bool PrivateMembershipRlwePirResponse::has_pir_response() const {
  return _internal_has_pir_response();
}
inline void PrivateMembershipRlwePirResponse::clear_pir_response() {
  if (GetArenaNoVirtual() == nullptr && pir_response_ != nullptr) {
    delete pir_response_;
  }
  pir_response_ = nullptr;
}
inline const ::private_membership::rlwe::PirResponse& PrivateMembershipRlwePirResponse::_internal_pir_response() const {
  const ::private_membership::rlwe::PirResponse* p = pir_response_;
  return p != nullptr ? *p : *reinterpret_cast<const ::private_membership::rlwe::PirResponse*>(
      &::private_membership::rlwe::_PirResponse_default_instance_);
}
inline const ::private_membership::rlwe::PirResponse& PrivateMembershipRlwePirResponse::pir_response() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PrivateMembershipRlwePirResponse.pir_response)
  return _internal_pir_response();
}
inline ::private_membership::rlwe::PirResponse* PrivateMembershipRlwePirResponse::release_pir_response() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.PrivateMembershipRlwePirResponse.pir_response)
  
  ::private_membership::rlwe::PirResponse* temp = pir_response_;
  pir_response_ = nullptr;
  return temp;
}
inline ::private_membership::rlwe::PirResponse* PrivateMembershipRlwePirResponse::_internal_mutable_pir_response() {
  
  if (pir_response_ == nullptr) {
    auto* p = CreateMaybeMessage<::private_membership::rlwe::PirResponse>(GetArenaNoVirtual());
    pir_response_ = p;
  }
  return pir_response_;
}
inline ::private_membership::rlwe::PirResponse* PrivateMembershipRlwePirResponse::mutable_pir_response() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PrivateMembershipRlwePirResponse.pir_response)
  return _internal_mutable_pir_response();
}
inline void PrivateMembershipRlwePirResponse::set_allocated_pir_response(::private_membership::rlwe::PirResponse* pir_response) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete pir_response_;
  }
  if (pir_response) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      pir_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pir_response, submessage_arena);
    }
    
  } else {
    
  }
  pir_response_ = pir_response;
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.PrivateMembershipRlwePirResponse.pir_response)
}

// -------------------------------------------------------------------

// PirRequest

// repeated .rlwe.SerializedNttPolynomial request = 1;
inline int PirRequest::_internal_request_size() const {
  return request_.size();
}
inline int PirRequest::request_size() const {
  return _internal_request_size();
}
inline ::rlwe::SerializedNttPolynomial* PirRequest::mutable_request(int index) {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PirRequest.request)
  return request_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rlwe::SerializedNttPolynomial >*
PirRequest::mutable_request() {
  // @@protoc_insertion_point(field_mutable_list:private_membership.rlwe.PirRequest.request)
  return &request_;
}
inline const ::rlwe::SerializedNttPolynomial& PirRequest::_internal_request(int index) const {
  return request_.Get(index);
}
inline const ::rlwe::SerializedNttPolynomial& PirRequest::request(int index) const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PirRequest.request)
  return _internal_request(index);
}
inline ::rlwe::SerializedNttPolynomial* PirRequest::_internal_add_request() {
  return request_.Add();
}
inline ::rlwe::SerializedNttPolynomial* PirRequest::add_request() {
  // @@protoc_insertion_point(field_add:private_membership.rlwe.PirRequest.request)
  return _internal_add_request();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rlwe::SerializedNttPolynomial >&
PirRequest::request() const {
  // @@protoc_insertion_point(field_list:private_membership.rlwe.PirRequest.request)
  return request_;
}

// bytes prng_seed = 2;
inline void PirRequest::clear_prng_seed() {
  prng_seed_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PirRequest::prng_seed() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PirRequest.prng_seed)
  return _internal_prng_seed();
}
inline void PirRequest::set_prng_seed(const std::string& value) {
  _internal_set_prng_seed(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PirRequest.prng_seed)
}
inline std::string* PirRequest::mutable_prng_seed() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PirRequest.prng_seed)
  return _internal_mutable_prng_seed();
}
inline const std::string& PirRequest::_internal_prng_seed() const {
  return prng_seed_.GetNoArena();
}
inline void PirRequest::_internal_set_prng_seed(const std::string& value) {
  
  prng_seed_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void PirRequest::set_prng_seed(std::string&& value) {
  
  prng_seed_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:private_membership.rlwe.PirRequest.prng_seed)
}
inline void PirRequest::set_prng_seed(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  prng_seed_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:private_membership.rlwe.PirRequest.prng_seed)
}
inline void PirRequest::set_prng_seed(const void* value, size_t size) {
  
  prng_seed_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:private_membership.rlwe.PirRequest.prng_seed)
}
inline std::string* PirRequest::_internal_mutable_prng_seed() {
  
  return prng_seed_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PirRequest::release_prng_seed() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.PirRequest.prng_seed)
  
  return prng_seed_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PirRequest::set_allocated_prng_seed(std::string* prng_seed) {
  if (prng_seed != nullptr) {
    
  } else {
    
  }
  prng_seed_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), prng_seed);
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.PirRequest.prng_seed)
}

// -------------------------------------------------------------------

// PirResponse

// repeated .rlwe.SerializedSymmetricRlweCiphertext response = 1;
inline int PirResponse::_internal_response_size() const {
  return response_.size();
}
inline int PirResponse::response_size() const {
  return _internal_response_size();
}
inline ::rlwe::SerializedSymmetricRlweCiphertext* PirResponse::mutable_response(int index) {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.PirResponse.response)
  return response_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rlwe::SerializedSymmetricRlweCiphertext >*
PirResponse::mutable_response() {
  // @@protoc_insertion_point(field_mutable_list:private_membership.rlwe.PirResponse.response)
  return &response_;
}
inline const ::rlwe::SerializedSymmetricRlweCiphertext& PirResponse::_internal_response(int index) const {
  return response_.Get(index);
}
inline const ::rlwe::SerializedSymmetricRlweCiphertext& PirResponse::response(int index) const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PirResponse.response)
  return _internal_response(index);
}
inline ::rlwe::SerializedSymmetricRlweCiphertext* PirResponse::_internal_add_response() {
  return response_.Add();
}
inline ::rlwe::SerializedSymmetricRlweCiphertext* PirResponse::add_response() {
  // @@protoc_insertion_point(field_add:private_membership.rlwe.PirResponse.response)
  return _internal_add_response();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rlwe::SerializedSymmetricRlweCiphertext >&
PirResponse::response() const {
  // @@protoc_insertion_point(field_list:private_membership.rlwe.PirResponse.response)
  return response_;
}

// int32 plaintext_entry_size = 2;
inline void PirResponse::clear_plaintext_entry_size() {
  plaintext_entry_size_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PirResponse::_internal_plaintext_entry_size() const {
  return plaintext_entry_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PirResponse::plaintext_entry_size() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.PirResponse.plaintext_entry_size)
  return _internal_plaintext_entry_size();
}
inline void PirResponse::_internal_set_plaintext_entry_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  plaintext_entry_size_ = value;
}
inline void PirResponse::set_plaintext_entry_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_plaintext_entry_size(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.PirResponse.plaintext_entry_size)
}

// -------------------------------------------------------------------

// EncryptedBucket_EncryptedIdValuePair

// bytes encrypted_id = 1;
inline void EncryptedBucket_EncryptedIdValuePair::clear_encrypted_id() {
  encrypted_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& EncryptedBucket_EncryptedIdValuePair::encrypted_id() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_id)
  return _internal_encrypted_id();
}
inline void EncryptedBucket_EncryptedIdValuePair::set_encrypted_id(const std::string& value) {
  _internal_set_encrypted_id(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_id)
}
inline std::string* EncryptedBucket_EncryptedIdValuePair::mutable_encrypted_id() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_id)
  return _internal_mutable_encrypted_id();
}
inline const std::string& EncryptedBucket_EncryptedIdValuePair::_internal_encrypted_id() const {
  return encrypted_id_.GetNoArena();
}
inline void EncryptedBucket_EncryptedIdValuePair::_internal_set_encrypted_id(const std::string& value) {
  
  encrypted_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void EncryptedBucket_EncryptedIdValuePair::set_encrypted_id(std::string&& value) {
  
  encrypted_id_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_id)
}
inline void EncryptedBucket_EncryptedIdValuePair::set_encrypted_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  encrypted_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_id)
}
inline void EncryptedBucket_EncryptedIdValuePair::set_encrypted_id(const void* value, size_t size) {
  
  encrypted_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_id)
}
inline std::string* EncryptedBucket_EncryptedIdValuePair::_internal_mutable_encrypted_id() {
  
  return encrypted_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* EncryptedBucket_EncryptedIdValuePair::release_encrypted_id() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_id)
  
  return encrypted_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void EncryptedBucket_EncryptedIdValuePair::set_allocated_encrypted_id(std::string* encrypted_id) {
  if (encrypted_id != nullptr) {
    
  } else {
    
  }
  encrypted_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_id);
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_id)
}

// bytes encrypted_value = 2;
inline void EncryptedBucket_EncryptedIdValuePair::clear_encrypted_value() {
  encrypted_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& EncryptedBucket_EncryptedIdValuePair::encrypted_value() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_value)
  return _internal_encrypted_value();
}
inline void EncryptedBucket_EncryptedIdValuePair::set_encrypted_value(const std::string& value) {
  _internal_set_encrypted_value(value);
  // @@protoc_insertion_point(field_set:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_value)
}
inline std::string* EncryptedBucket_EncryptedIdValuePair::mutable_encrypted_value() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_value)
  return _internal_mutable_encrypted_value();
}
inline const std::string& EncryptedBucket_EncryptedIdValuePair::_internal_encrypted_value() const {
  return encrypted_value_.GetNoArena();
}
inline void EncryptedBucket_EncryptedIdValuePair::_internal_set_encrypted_value(const std::string& value) {
  
  encrypted_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void EncryptedBucket_EncryptedIdValuePair::set_encrypted_value(std::string&& value) {
  
  encrypted_value_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_value)
}
inline void EncryptedBucket_EncryptedIdValuePair::set_encrypted_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  encrypted_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_value)
}
inline void EncryptedBucket_EncryptedIdValuePair::set_encrypted_value(const void* value, size_t size) {
  
  encrypted_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_value)
}
inline std::string* EncryptedBucket_EncryptedIdValuePair::_internal_mutable_encrypted_value() {
  
  return encrypted_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* EncryptedBucket_EncryptedIdValuePair::release_encrypted_value() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_value)
  
  return encrypted_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void EncryptedBucket_EncryptedIdValuePair::set_allocated_encrypted_value(std::string* encrypted_value) {
  if (encrypted_value != nullptr) {
    
  } else {
    
  }
  encrypted_value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_value);
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair.encrypted_value)
}

// -------------------------------------------------------------------

// EncryptedBucket

// repeated .private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair encrypted_id_value_pairs = 1;
inline int EncryptedBucket::_internal_encrypted_id_value_pairs_size() const {
  return encrypted_id_value_pairs_.size();
}
inline int EncryptedBucket::encrypted_id_value_pairs_size() const {
  return _internal_encrypted_id_value_pairs_size();
}
inline void EncryptedBucket::clear_encrypted_id_value_pairs() {
  encrypted_id_value_pairs_.Clear();
}
inline ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair* EncryptedBucket::mutable_encrypted_id_value_pairs(int index) {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.EncryptedBucket.encrypted_id_value_pairs)
  return encrypted_id_value_pairs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair >*
EncryptedBucket::mutable_encrypted_id_value_pairs() {
  // @@protoc_insertion_point(field_mutable_list:private_membership.rlwe.EncryptedBucket.encrypted_id_value_pairs)
  return &encrypted_id_value_pairs_;
}
inline const ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair& EncryptedBucket::_internal_encrypted_id_value_pairs(int index) const {
  return encrypted_id_value_pairs_.Get(index);
}
inline const ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair& EncryptedBucket::encrypted_id_value_pairs(int index) const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.EncryptedBucket.encrypted_id_value_pairs)
  return _internal_encrypted_id_value_pairs(index);
}
inline ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair* EncryptedBucket::_internal_add_encrypted_id_value_pairs() {
  return encrypted_id_value_pairs_.Add();
}
inline ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair* EncryptedBucket::add_encrypted_id_value_pairs() {
  // @@protoc_insertion_point(field_add:private_membership.rlwe.EncryptedBucket.encrypted_id_value_pairs)
  return _internal_add_encrypted_id_value_pairs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair >&
EncryptedBucket::encrypted_id_value_pairs() const {
  // @@protoc_insertion_point(field_list:private_membership.rlwe.EncryptedBucket.encrypted_id_value_pairs)
  return encrypted_id_value_pairs_;
}

// -------------------------------------------------------------------

// RlweMembershipResponses_MembershipResponseEntry

// .private_membership.rlwe.RlwePlaintextId plaintext_id = 1;
inline bool RlweMembershipResponses_MembershipResponseEntry::_internal_has_plaintext_id() const {
  return this != internal_default_instance() && plaintext_id_ != nullptr;
}
inline bool RlweMembershipResponses_MembershipResponseEntry::has_plaintext_id() const {
  return _internal_has_plaintext_id();
}
inline void RlweMembershipResponses_MembershipResponseEntry::clear_plaintext_id() {
  if (GetArenaNoVirtual() == nullptr && plaintext_id_ != nullptr) {
    delete plaintext_id_;
  }
  plaintext_id_ = nullptr;
}
inline const ::private_membership::rlwe::RlwePlaintextId& RlweMembershipResponses_MembershipResponseEntry::_internal_plaintext_id() const {
  const ::private_membership::rlwe::RlwePlaintextId* p = plaintext_id_;
  return p != nullptr ? *p : *reinterpret_cast<const ::private_membership::rlwe::RlwePlaintextId*>(
      &::private_membership::rlwe::_RlwePlaintextId_default_instance_);
}
inline const ::private_membership::rlwe::RlwePlaintextId& RlweMembershipResponses_MembershipResponseEntry::plaintext_id() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry.plaintext_id)
  return _internal_plaintext_id();
}
inline ::private_membership::rlwe::RlwePlaintextId* RlweMembershipResponses_MembershipResponseEntry::release_plaintext_id() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry.plaintext_id)
  
  ::private_membership::rlwe::RlwePlaintextId* temp = plaintext_id_;
  plaintext_id_ = nullptr;
  return temp;
}
inline ::private_membership::rlwe::RlwePlaintextId* RlweMembershipResponses_MembershipResponseEntry::_internal_mutable_plaintext_id() {
  
  if (plaintext_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::private_membership::rlwe::RlwePlaintextId>(GetArenaNoVirtual());
    plaintext_id_ = p;
  }
  return plaintext_id_;
}
inline ::private_membership::rlwe::RlwePlaintextId* RlweMembershipResponses_MembershipResponseEntry::mutable_plaintext_id() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry.plaintext_id)
  return _internal_mutable_plaintext_id();
}
inline void RlweMembershipResponses_MembershipResponseEntry::set_allocated_plaintext_id(::private_membership::rlwe::RlwePlaintextId* plaintext_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete plaintext_id_;
  }
  if (plaintext_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      plaintext_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, plaintext_id, submessage_arena);
    }
    
  } else {
    
  }
  plaintext_id_ = plaintext_id;
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry.plaintext_id)
}

// .private_membership.MembershipResponse membership_response = 2;
inline bool RlweMembershipResponses_MembershipResponseEntry::_internal_has_membership_response() const {
  return this != internal_default_instance() && membership_response_ != nullptr;
}
inline bool RlweMembershipResponses_MembershipResponseEntry::has_membership_response() const {
  return _internal_has_membership_response();
}
inline const ::private_membership::MembershipResponse& RlweMembershipResponses_MembershipResponseEntry::_internal_membership_response() const {
  const ::private_membership::MembershipResponse* p = membership_response_;
  return p != nullptr ? *p : *reinterpret_cast<const ::private_membership::MembershipResponse*>(
      &::private_membership::_MembershipResponse_default_instance_);
}
inline const ::private_membership::MembershipResponse& RlweMembershipResponses_MembershipResponseEntry::membership_response() const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry.membership_response)
  return _internal_membership_response();
}
inline ::private_membership::MembershipResponse* RlweMembershipResponses_MembershipResponseEntry::release_membership_response() {
  // @@protoc_insertion_point(field_release:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry.membership_response)
  
  ::private_membership::MembershipResponse* temp = membership_response_;
  membership_response_ = nullptr;
  return temp;
}
inline ::private_membership::MembershipResponse* RlweMembershipResponses_MembershipResponseEntry::_internal_mutable_membership_response() {
  
  if (membership_response_ == nullptr) {
    auto* p = CreateMaybeMessage<::private_membership::MembershipResponse>(GetArenaNoVirtual());
    membership_response_ = p;
  }
  return membership_response_;
}
inline ::private_membership::MembershipResponse* RlweMembershipResponses_MembershipResponseEntry::mutable_membership_response() {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry.membership_response)
  return _internal_mutable_membership_response();
}
inline void RlweMembershipResponses_MembershipResponseEntry::set_allocated_membership_response(::private_membership::MembershipResponse* membership_response) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(membership_response_);
  }
  if (membership_response) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      membership_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, membership_response, submessage_arena);
    }
    
  } else {
    
  }
  membership_response_ = membership_response;
  // @@protoc_insertion_point(field_set_allocated:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry.membership_response)
}

// -------------------------------------------------------------------

// RlweMembershipResponses

// repeated .private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry membership_responses = 1;
inline int RlweMembershipResponses::_internal_membership_responses_size() const {
  return membership_responses_.size();
}
inline int RlweMembershipResponses::membership_responses_size() const {
  return _internal_membership_responses_size();
}
inline void RlweMembershipResponses::clear_membership_responses() {
  membership_responses_.Clear();
}
inline ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry* RlweMembershipResponses::mutable_membership_responses(int index) {
  // @@protoc_insertion_point(field_mutable:private_membership.rlwe.RlweMembershipResponses.membership_responses)
  return membership_responses_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry >*
RlweMembershipResponses::mutable_membership_responses() {
  // @@protoc_insertion_point(field_mutable_list:private_membership.rlwe.RlweMembershipResponses.membership_responses)
  return &membership_responses_;
}
inline const ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry& RlweMembershipResponses::_internal_membership_responses(int index) const {
  return membership_responses_.Get(index);
}
inline const ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry& RlweMembershipResponses::membership_responses(int index) const {
  // @@protoc_insertion_point(field_get:private_membership.rlwe.RlweMembershipResponses.membership_responses)
  return _internal_membership_responses(index);
}
inline ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry* RlweMembershipResponses::_internal_add_membership_responses() {
  return membership_responses_.Add();
}
inline ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry* RlweMembershipResponses::add_membership_responses() {
  // @@protoc_insertion_point(field_add:private_membership.rlwe.RlweMembershipResponses.membership_responses)
  return _internal_add_membership_responses();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry >&
RlweMembershipResponses::membership_responses() const {
  // @@protoc_insertion_point(field_list:private_membership.rlwe.RlweMembershipResponses.membership_responses)
  return membership_responses_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace rlwe
}  // namespace private_membership

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::private_membership::rlwe::RlweUseCase> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_private_5fmembership_5frlwe_2eproto