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

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

#include "private_membership_rlwe.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DoublyEncryptedId_private_5fmembership_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MembershipResponse_private_5fmembership_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_EncryptedBucket_EncryptedIdValuePair_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_EncryptedBucketsParameters_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HashedBucketsParameters_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PirRequest_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PirResponse_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PrivateMembershipRlwePirResponse_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_PrivateMembershipRlweQuery_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PrivateMembershipRlweQuery_HashedBucketId_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RlweMembershipResponses_MembershipResponseEntry_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RlweParameters_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RlwePlaintextId_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_private_5fmembership_5frlwe_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Uint128_private_5fmembership_5frlwe_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_serialization_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SerializedNttPolynomial_serialization_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_serialization_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_SerializedSymmetricRlweCiphertext_serialization_2eproto;
namespace private_membership {
namespace rlwe {
class PrivateMembershipRlweOprfRequestDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PrivateMembershipRlweOprfRequest> _instance;
} _PrivateMembershipRlweOprfRequest_default_instance_;
class PrivateMembershipRlweOprfResponseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PrivateMembershipRlweOprfResponse> _instance;
} _PrivateMembershipRlweOprfResponse_default_instance_;
class PrivateMembershipRlweQueryRequestDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PrivateMembershipRlweQueryRequest> _instance;
} _PrivateMembershipRlweQueryRequest_default_instance_;
class PrivateMembershipRlweQueryResponseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PrivateMembershipRlweQueryResponse> _instance;
} _PrivateMembershipRlweQueryResponse_default_instance_;
class RlwePlaintextIdDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RlwePlaintextId> _instance;
} _RlwePlaintextId_default_instance_;
class HashedBucketsParametersDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<HashedBucketsParameters> _instance;
} _HashedBucketsParameters_default_instance_;
class EncryptedBucketsParametersDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<EncryptedBucketsParameters> _instance;
} _EncryptedBucketsParameters_default_instance_;
class RlweParametersDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RlweParameters> _instance;
} _RlweParameters_default_instance_;
class Uint128DefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Uint128> _instance;
} _Uint128_default_instance_;
class PrivateMembershipRlweQuery_HashedBucketIdDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PrivateMembershipRlweQuery_HashedBucketId> _instance;
} _PrivateMembershipRlweQuery_HashedBucketId_default_instance_;
class PrivateMembershipRlweQueryDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PrivateMembershipRlweQuery> _instance;
} _PrivateMembershipRlweQuery_default_instance_;
class PrivateMembershipRlwePirResponseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PrivateMembershipRlwePirResponse> _instance;
} _PrivateMembershipRlwePirResponse_default_instance_;
class PirRequestDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PirRequest> _instance;
} _PirRequest_default_instance_;
class PirResponseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PirResponse> _instance;
} _PirResponse_default_instance_;
class EncryptedBucket_EncryptedIdValuePairDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<EncryptedBucket_EncryptedIdValuePair> _instance;
} _EncryptedBucket_EncryptedIdValuePair_default_instance_;
class EncryptedBucketDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<EncryptedBucket> _instance;
} _EncryptedBucket_default_instance_;
class RlweMembershipResponses_MembershipResponseEntryDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RlweMembershipResponses_MembershipResponseEntry> _instance;
} _RlweMembershipResponses_MembershipResponseEntry_default_instance_;
class RlweMembershipResponsesDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RlweMembershipResponses> _instance;
} _RlweMembershipResponses_default_instance_;
}  // namespace rlwe
}  // namespace private_membership
static void InitDefaultsscc_info_EncryptedBucket_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_EncryptedBucket_default_instance_;
    new (ptr) ::private_membership::rlwe::EncryptedBucket();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::EncryptedBucket::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_EncryptedBucket_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_EncryptedBucket_private_5fmembership_5frlwe_2eproto}, {
      &scc_info_EncryptedBucket_EncryptedIdValuePair_private_5fmembership_5frlwe_2eproto.base,}};

static void InitDefaultsscc_info_EncryptedBucket_EncryptedIdValuePair_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_EncryptedBucket_EncryptedIdValuePair_default_instance_;
    new (ptr) ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_EncryptedBucket_EncryptedIdValuePair_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_EncryptedBucket_EncryptedIdValuePair_private_5fmembership_5frlwe_2eproto}, {}};

static void InitDefaultsscc_info_EncryptedBucketsParameters_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_EncryptedBucketsParameters_default_instance_;
    new (ptr) ::private_membership::rlwe::EncryptedBucketsParameters();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::EncryptedBucketsParameters::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_EncryptedBucketsParameters_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_EncryptedBucketsParameters_private_5fmembership_5frlwe_2eproto}, {}};

static void InitDefaultsscc_info_HashedBucketsParameters_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_HashedBucketsParameters_default_instance_;
    new (ptr) ::private_membership::rlwe::HashedBucketsParameters();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::HashedBucketsParameters::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HashedBucketsParameters_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_HashedBucketsParameters_private_5fmembership_5frlwe_2eproto}, {}};

static void InitDefaultsscc_info_PirRequest_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_PirRequest_default_instance_;
    new (ptr) ::private_membership::rlwe::PirRequest();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::PirRequest::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PirRequest_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_PirRequest_private_5fmembership_5frlwe_2eproto}, {
      &scc_info_SerializedNttPolynomial_serialization_2eproto.base,}};

static void InitDefaultsscc_info_PirResponse_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_PirResponse_default_instance_;
    new (ptr) ::private_membership::rlwe::PirResponse();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::PirResponse::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PirResponse_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_PirResponse_private_5fmembership_5frlwe_2eproto}, {
      &scc_info_SerializedSymmetricRlweCiphertext_serialization_2eproto.base,}};

static void InitDefaultsscc_info_PrivateMembershipRlweOprfRequest_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_PrivateMembershipRlweOprfRequest_default_instance_;
    new (ptr) ::private_membership::rlwe::PrivateMembershipRlweOprfRequest();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::PrivateMembershipRlweOprfRequest::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PrivateMembershipRlweOprfRequest_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_PrivateMembershipRlweOprfRequest_private_5fmembership_5frlwe_2eproto}, {}};

static void InitDefaultsscc_info_PrivateMembershipRlweOprfResponse_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_PrivateMembershipRlweOprfResponse_default_instance_;
    new (ptr) ::private_membership::rlwe::PrivateMembershipRlweOprfResponse();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::PrivateMembershipRlweOprfResponse::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_PrivateMembershipRlweOprfResponse_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, 0, InitDefaultsscc_info_PrivateMembershipRlweOprfResponse_private_5fmembership_5frlwe_2eproto}, {
      &scc_info_DoublyEncryptedId_private_5fmembership_2eproto.base,
      &scc_info_HashedBucketsParameters_private_5fmembership_5frlwe_2eproto.base,
      &scc_info_EncryptedBucketsParameters_private_5fmembership_5frlwe_2eproto.base,
      &scc_info_RlweParameters_private_5fmembership_5frlwe_2eproto.base,}};

static void InitDefaultsscc_info_PrivateMembershipRlwePirResponse_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_PrivateMembershipRlwePirResponse_default_instance_;
    new (ptr) ::private_membership::rlwe::PrivateMembershipRlwePirResponse();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::PrivateMembershipRlwePirResponse::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PrivateMembershipRlwePirResponse_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_PrivateMembershipRlwePirResponse_private_5fmembership_5frlwe_2eproto}, {
      &scc_info_PirResponse_private_5fmembership_5frlwe_2eproto.base,}};

static void InitDefaultsscc_info_PrivateMembershipRlweQuery_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_PrivateMembershipRlweQuery_default_instance_;
    new (ptr) ::private_membership::rlwe::PrivateMembershipRlweQuery();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::PrivateMembershipRlweQuery::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_PrivateMembershipRlweQuery_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_PrivateMembershipRlweQuery_private_5fmembership_5frlwe_2eproto}, {
      &scc_info_PirRequest_private_5fmembership_5frlwe_2eproto.base,
      &scc_info_PrivateMembershipRlweQuery_HashedBucketId_private_5fmembership_5frlwe_2eproto.base,}};

static void InitDefaultsscc_info_PrivateMembershipRlweQuery_HashedBucketId_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_PrivateMembershipRlweQuery_HashedBucketId_default_instance_;
    new (ptr) ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PrivateMembershipRlweQuery_HashedBucketId_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_PrivateMembershipRlweQuery_HashedBucketId_private_5fmembership_5frlwe_2eproto}, {}};

static void InitDefaultsscc_info_PrivateMembershipRlweQueryRequest_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_PrivateMembershipRlweQueryRequest_default_instance_;
    new (ptr) ::private_membership::rlwe::PrivateMembershipRlweQueryRequest();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::PrivateMembershipRlweQueryRequest::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PrivateMembershipRlweQueryRequest_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_PrivateMembershipRlweQueryRequest_private_5fmembership_5frlwe_2eproto}, {
      &scc_info_PrivateMembershipRlweQuery_private_5fmembership_5frlwe_2eproto.base,}};

static void InitDefaultsscc_info_PrivateMembershipRlweQueryResponse_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_PrivateMembershipRlweQueryResponse_default_instance_;
    new (ptr) ::private_membership::rlwe::PrivateMembershipRlweQueryResponse();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::PrivateMembershipRlweQueryResponse::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PrivateMembershipRlweQueryResponse_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_PrivateMembershipRlweQueryResponse_private_5fmembership_5frlwe_2eproto}, {
      &scc_info_PrivateMembershipRlwePirResponse_private_5fmembership_5frlwe_2eproto.base,}};

static void InitDefaultsscc_info_RlweMembershipResponses_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_RlweMembershipResponses_default_instance_;
    new (ptr) ::private_membership::rlwe::RlweMembershipResponses();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::RlweMembershipResponses::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RlweMembershipResponses_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_RlweMembershipResponses_private_5fmembership_5frlwe_2eproto}, {
      &scc_info_RlweMembershipResponses_MembershipResponseEntry_private_5fmembership_5frlwe_2eproto.base,}};

static void InitDefaultsscc_info_RlweMembershipResponses_MembershipResponseEntry_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_RlweMembershipResponses_MembershipResponseEntry_default_instance_;
    new (ptr) ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RlweMembershipResponses_MembershipResponseEntry_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_RlweMembershipResponses_MembershipResponseEntry_private_5fmembership_5frlwe_2eproto}, {
      &scc_info_RlwePlaintextId_private_5fmembership_5frlwe_2eproto.base,
      &scc_info_MembershipResponse_private_5fmembership_2eproto.base,}};

static void InitDefaultsscc_info_RlweParameters_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_RlweParameters_default_instance_;
    new (ptr) ::private_membership::rlwe::RlweParameters();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::RlweParameters::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RlweParameters_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_RlweParameters_private_5fmembership_5frlwe_2eproto}, {
      &scc_info_Uint128_private_5fmembership_5frlwe_2eproto.base,}};

static void InitDefaultsscc_info_RlwePlaintextId_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_RlwePlaintextId_default_instance_;
    new (ptr) ::private_membership::rlwe::RlwePlaintextId();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::RlwePlaintextId::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RlwePlaintextId_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_RlwePlaintextId_private_5fmembership_5frlwe_2eproto}, {}};

static void InitDefaultsscc_info_Uint128_private_5fmembership_5frlwe_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::rlwe::_Uint128_default_instance_;
    new (ptr) ::private_membership::rlwe::Uint128();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::rlwe::Uint128::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Uint128_private_5fmembership_5frlwe_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Uint128_private_5fmembership_5frlwe_2eproto}, {}};

namespace private_membership {
namespace rlwe {
bool RlweUseCase_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 5:
    case 12:
    case 13:
    case 14:
    case 15:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> RlweUseCase_strings[9] = {};

static const char RlweUseCase_names[] =
  "CROS_DEVICE_SECONDARY_STATE"
  "CROS_DEVICE_STATE"
  "CROS_FRESNEL_ALL_TIME"
  "CROS_FRESNEL_DAILY"
  "CROS_FRESNEL_MONTHLY"
  "RLWE_USE_CASE_UNDEFINED"
  "TEST_USE_CASE"
  "TEST_USE_CASE2"
  "TEST_USE_CASE3";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry RlweUseCase_entries[] = {
  { {RlweUseCase_names + 0, 27}, 12 },
  { {RlweUseCase_names + 27, 17}, 5 },
  { {RlweUseCase_names + 44, 21}, 15 },
  { {RlweUseCase_names + 65, 18}, 13 },
  { {RlweUseCase_names + 83, 20}, 14 },
  { {RlweUseCase_names + 103, 23}, 0 },
  { {RlweUseCase_names + 126, 13}, 1 },
  { {RlweUseCase_names + 139, 14}, 2 },
  { {RlweUseCase_names + 153, 14}, 3 },
};

static const int RlweUseCase_entries_by_number[] = {
  5, // 0 -> RLWE_USE_CASE_UNDEFINED
  6, // 1 -> TEST_USE_CASE
  7, // 2 -> TEST_USE_CASE2
  8, // 3 -> TEST_USE_CASE3
  1, // 5 -> CROS_DEVICE_STATE
  0, // 12 -> CROS_DEVICE_SECONDARY_STATE
  3, // 13 -> CROS_FRESNEL_DAILY
  4, // 14 -> CROS_FRESNEL_MONTHLY
  2, // 15 -> CROS_FRESNEL_ALL_TIME
};

const std::string& RlweUseCase_Name(
    RlweUseCase value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          RlweUseCase_entries,
          RlweUseCase_entries_by_number,
          9, RlweUseCase_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      RlweUseCase_entries,
      RlweUseCase_entries_by_number,
      9, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     RlweUseCase_strings[idx].get();
}
bool RlweUseCase_Parse(
    const std::string& name, RlweUseCase* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      RlweUseCase_entries, 9, name, &int_value);
  if (success) {
    *value = static_cast<RlweUseCase>(int_value);
  }
  return success;
}

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

void PrivateMembershipRlweOprfRequest::InitAsDefaultInstance() {
}
class PrivateMembershipRlweOprfRequest::_Internal {
 public:
};

PrivateMembershipRlweOprfRequest::PrivateMembershipRlweOprfRequest()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.PrivateMembershipRlweOprfRequest)
}
PrivateMembershipRlweOprfRequest::PrivateMembershipRlweOprfRequest(const PrivateMembershipRlweOprfRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      encrypted_ids_(from.encrypted_ids_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  use_case_ = from.use_case_;
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.PrivateMembershipRlweOprfRequest)
}

void PrivateMembershipRlweOprfRequest::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PrivateMembershipRlweOprfRequest_private_5fmembership_5frlwe_2eproto.base);
  use_case_ = 0;
}

PrivateMembershipRlweOprfRequest::~PrivateMembershipRlweOprfRequest() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.PrivateMembershipRlweOprfRequest)
  SharedDtor();
}

void PrivateMembershipRlweOprfRequest::SharedDtor() {
}

void PrivateMembershipRlweOprfRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PrivateMembershipRlweOprfRequest& PrivateMembershipRlweOprfRequest::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PrivateMembershipRlweOprfRequest_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void PrivateMembershipRlweOprfRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.PrivateMembershipRlweOprfRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  encrypted_ids_.Clear();
  use_case_ = 0;
  _internal_metadata_.Clear();
}

const char* PrivateMembershipRlweOprfRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated bytes encrypted_ids = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_encrypted_ids();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // .private_membership.rlwe.RlweUseCase use_case = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          _internal_set_use_case(static_cast<::private_membership::rlwe::RlweUseCase>(val));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* PrivateMembershipRlweOprfRequest::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.PrivateMembershipRlweOprfRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated bytes encrypted_ids = 1;
  for (int i = 0, n = this->_internal_encrypted_ids_size(); i < n; i++) {
    const auto& s = this->_internal_encrypted_ids(i);
    target = stream->WriteBytes(1, s, target);
  }

  // .private_membership.rlwe.RlweUseCase use_case = 2;
  if (this->use_case() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_use_case(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.PrivateMembershipRlweOprfRequest)
  return target;
}

size_t PrivateMembershipRlweOprfRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.PrivateMembershipRlweOprfRequest)
  size_t total_size = 0;

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

  // repeated bytes encrypted_ids = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(encrypted_ids_.size());
  for (int i = 0, n = encrypted_ids_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
      encrypted_ids_.Get(i));
  }

  // .private_membership.rlwe.RlweUseCase use_case = 2;
  if (this->use_case() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_use_case());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void PrivateMembershipRlweOprfRequest::MergeFrom(const PrivateMembershipRlweOprfRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.PrivateMembershipRlweOprfRequest)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  encrypted_ids_.MergeFrom(from.encrypted_ids_);
  if (from.use_case() != 0) {
    _internal_set_use_case(from._internal_use_case());
  }
}

void PrivateMembershipRlweOprfRequest::CopyFrom(const PrivateMembershipRlweOprfRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.PrivateMembershipRlweOprfRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PrivateMembershipRlweOprfRequest::InternalSwap(PrivateMembershipRlweOprfRequest* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  encrypted_ids_.InternalSwap(&other->encrypted_ids_);
  swap(use_case_, other->use_case_);
}

std::string PrivateMembershipRlweOprfRequest::GetTypeName() const {
  return "private_membership.rlwe.PrivateMembershipRlweOprfRequest";
}


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

void PrivateMembershipRlweOprfResponse::InitAsDefaultInstance() {
  ::private_membership::rlwe::_PrivateMembershipRlweOprfResponse_default_instance_._instance.get_mutable()->hashed_buckets_parameters_ = const_cast< ::private_membership::rlwe::HashedBucketsParameters*>(
      ::private_membership::rlwe::HashedBucketsParameters::internal_default_instance());
  ::private_membership::rlwe::_PrivateMembershipRlweOprfResponse_default_instance_._instance.get_mutable()->encrypted_buckets_parameters_ = const_cast< ::private_membership::rlwe::EncryptedBucketsParameters*>(
      ::private_membership::rlwe::EncryptedBucketsParameters::internal_default_instance());
  ::private_membership::rlwe::_PrivateMembershipRlweOprfResponse_default_instance_._instance.get_mutable()->rlwe_parameters_ = const_cast< ::private_membership::rlwe::RlweParameters*>(
      ::private_membership::rlwe::RlweParameters::internal_default_instance());
}
class PrivateMembershipRlweOprfResponse::_Internal {
 public:
  static const ::private_membership::rlwe::HashedBucketsParameters& hashed_buckets_parameters(const PrivateMembershipRlweOprfResponse* msg);
  static const ::private_membership::rlwe::EncryptedBucketsParameters& encrypted_buckets_parameters(const PrivateMembershipRlweOprfResponse* msg);
  static const ::private_membership::rlwe::RlweParameters& rlwe_parameters(const PrivateMembershipRlweOprfResponse* msg);
};

const ::private_membership::rlwe::HashedBucketsParameters&
PrivateMembershipRlweOprfResponse::_Internal::hashed_buckets_parameters(const PrivateMembershipRlweOprfResponse* msg) {
  return *msg->hashed_buckets_parameters_;
}
const ::private_membership::rlwe::EncryptedBucketsParameters&
PrivateMembershipRlweOprfResponse::_Internal::encrypted_buckets_parameters(const PrivateMembershipRlweOprfResponse* msg) {
  return *msg->encrypted_buckets_parameters_;
}
const ::private_membership::rlwe::RlweParameters&
PrivateMembershipRlweOprfResponse::_Internal::rlwe_parameters(const PrivateMembershipRlweOprfResponse* msg) {
  return *msg->rlwe_parameters_;
}
void PrivateMembershipRlweOprfResponse::clear_doubly_encrypted_ids() {
  doubly_encrypted_ids_.Clear();
}
PrivateMembershipRlweOprfResponse::PrivateMembershipRlweOprfResponse()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.PrivateMembershipRlweOprfResponse)
}
PrivateMembershipRlweOprfResponse::PrivateMembershipRlweOprfResponse(const PrivateMembershipRlweOprfResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      doubly_encrypted_ids_(from.doubly_encrypted_ids_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_hashed_buckets_parameters()) {
    hashed_buckets_parameters_ = new ::private_membership::rlwe::HashedBucketsParameters(*from.hashed_buckets_parameters_);
  } else {
    hashed_buckets_parameters_ = nullptr;
  }
  if (from._internal_has_encrypted_buckets_parameters()) {
    encrypted_buckets_parameters_ = new ::private_membership::rlwe::EncryptedBucketsParameters(*from.encrypted_buckets_parameters_);
  } else {
    encrypted_buckets_parameters_ = nullptr;
  }
  if (from._internal_has_rlwe_parameters()) {
    rlwe_parameters_ = new ::private_membership::rlwe::RlweParameters(*from.rlwe_parameters_);
  } else {
    rlwe_parameters_ = nullptr;
  }
  key_version_ = from.key_version_;
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.PrivateMembershipRlweOprfResponse)
}

void PrivateMembershipRlweOprfResponse::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PrivateMembershipRlweOprfResponse_private_5fmembership_5frlwe_2eproto.base);
  ::memset(&hashed_buckets_parameters_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&key_version_) -
      reinterpret_cast<char*>(&hashed_buckets_parameters_)) + sizeof(key_version_));
}

PrivateMembershipRlweOprfResponse::~PrivateMembershipRlweOprfResponse() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.PrivateMembershipRlweOprfResponse)
  SharedDtor();
}

void PrivateMembershipRlweOprfResponse::SharedDtor() {
  if (this != internal_default_instance()) delete hashed_buckets_parameters_;
  if (this != internal_default_instance()) delete encrypted_buckets_parameters_;
  if (this != internal_default_instance()) delete rlwe_parameters_;
}

void PrivateMembershipRlweOprfResponse::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PrivateMembershipRlweOprfResponse& PrivateMembershipRlweOprfResponse::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PrivateMembershipRlweOprfResponse_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void PrivateMembershipRlweOprfResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.PrivateMembershipRlweOprfResponse)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  doubly_encrypted_ids_.Clear();
  if (GetArenaNoVirtual() == nullptr && hashed_buckets_parameters_ != nullptr) {
    delete hashed_buckets_parameters_;
  }
  hashed_buckets_parameters_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && encrypted_buckets_parameters_ != nullptr) {
    delete encrypted_buckets_parameters_;
  }
  encrypted_buckets_parameters_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && rlwe_parameters_ != nullptr) {
    delete rlwe_parameters_;
  }
  rlwe_parameters_ = nullptr;
  key_version_ = PROTOBUF_LONGLONG(0);
  _internal_metadata_.Clear();
}

const char* PrivateMembershipRlweOprfResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .private_membership.DoublyEncryptedId doubly_encrypted_ids = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_doubly_encrypted_ids(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // .private_membership.rlwe.HashedBucketsParameters hashed_buckets_parameters = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_hashed_buckets_parameters(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .private_membership.rlwe.EncryptedBucketsParameters encrypted_buckets_parameters = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_encrypted_buckets_parameters(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .private_membership.rlwe.RlweParameters rlwe_parameters = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_rlwe_parameters(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int64 key_version = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          key_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* PrivateMembershipRlweOprfResponse::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.PrivateMembershipRlweOprfResponse)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .private_membership.DoublyEncryptedId doubly_encrypted_ids = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_doubly_encrypted_ids_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_doubly_encrypted_ids(i), target, stream);
  }

  // .private_membership.rlwe.HashedBucketsParameters hashed_buckets_parameters = 2;
  if (this->has_hashed_buckets_parameters()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::hashed_buckets_parameters(this), target, stream);
  }

  // .private_membership.rlwe.EncryptedBucketsParameters encrypted_buckets_parameters = 3;
  if (this->has_encrypted_buckets_parameters()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::encrypted_buckets_parameters(this), target, stream);
  }

  // .private_membership.rlwe.RlweParameters rlwe_parameters = 4;
  if (this->has_rlwe_parameters()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::rlwe_parameters(this), target, stream);
  }

  // int64 key_version = 5;
  if (this->key_version() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(5, this->_internal_key_version(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.PrivateMembershipRlweOprfResponse)
  return target;
}

size_t PrivateMembershipRlweOprfResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.PrivateMembershipRlweOprfResponse)
  size_t total_size = 0;

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

  // repeated .private_membership.DoublyEncryptedId doubly_encrypted_ids = 1;
  total_size += 1UL * this->_internal_doubly_encrypted_ids_size();
  for (const auto& msg : this->doubly_encrypted_ids_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .private_membership.rlwe.HashedBucketsParameters hashed_buckets_parameters = 2;
  if (this->has_hashed_buckets_parameters()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *hashed_buckets_parameters_);
  }

  // .private_membership.rlwe.EncryptedBucketsParameters encrypted_buckets_parameters = 3;
  if (this->has_encrypted_buckets_parameters()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *encrypted_buckets_parameters_);
  }

  // .private_membership.rlwe.RlweParameters rlwe_parameters = 4;
  if (this->has_rlwe_parameters()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *rlwe_parameters_);
  }

  // int64 key_version = 5;
  if (this->key_version() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
        this->_internal_key_version());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void PrivateMembershipRlweOprfResponse::MergeFrom(const PrivateMembershipRlweOprfResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.PrivateMembershipRlweOprfResponse)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  doubly_encrypted_ids_.MergeFrom(from.doubly_encrypted_ids_);
  if (from.has_hashed_buckets_parameters()) {
    _internal_mutable_hashed_buckets_parameters()->::private_membership::rlwe::HashedBucketsParameters::MergeFrom(from._internal_hashed_buckets_parameters());
  }
  if (from.has_encrypted_buckets_parameters()) {
    _internal_mutable_encrypted_buckets_parameters()->::private_membership::rlwe::EncryptedBucketsParameters::MergeFrom(from._internal_encrypted_buckets_parameters());
  }
  if (from.has_rlwe_parameters()) {
    _internal_mutable_rlwe_parameters()->::private_membership::rlwe::RlweParameters::MergeFrom(from._internal_rlwe_parameters());
  }
  if (from.key_version() != 0) {
    _internal_set_key_version(from._internal_key_version());
  }
}

void PrivateMembershipRlweOprfResponse::CopyFrom(const PrivateMembershipRlweOprfResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.PrivateMembershipRlweOprfResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PrivateMembershipRlweOprfResponse::InternalSwap(PrivateMembershipRlweOprfResponse* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  doubly_encrypted_ids_.InternalSwap(&other->doubly_encrypted_ids_);
  swap(hashed_buckets_parameters_, other->hashed_buckets_parameters_);
  swap(encrypted_buckets_parameters_, other->encrypted_buckets_parameters_);
  swap(rlwe_parameters_, other->rlwe_parameters_);
  swap(key_version_, other->key_version_);
}

std::string PrivateMembershipRlweOprfResponse::GetTypeName() const {
  return "private_membership.rlwe.PrivateMembershipRlweOprfResponse";
}


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

void PrivateMembershipRlweQueryRequest::InitAsDefaultInstance() {
}
class PrivateMembershipRlweQueryRequest::_Internal {
 public:
};

PrivateMembershipRlweQueryRequest::PrivateMembershipRlweQueryRequest()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.PrivateMembershipRlweQueryRequest)
}
PrivateMembershipRlweQueryRequest::PrivateMembershipRlweQueryRequest(const PrivateMembershipRlweQueryRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      queries_(from.queries_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&key_version_, &from.key_version_,
    static_cast<size_t>(reinterpret_cast<char*>(&use_case_) -
    reinterpret_cast<char*>(&key_version_)) + sizeof(use_case_));
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.PrivateMembershipRlweQueryRequest)
}

void PrivateMembershipRlweQueryRequest::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PrivateMembershipRlweQueryRequest_private_5fmembership_5frlwe_2eproto.base);
  ::memset(&key_version_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&use_case_) -
      reinterpret_cast<char*>(&key_version_)) + sizeof(use_case_));
}

PrivateMembershipRlweQueryRequest::~PrivateMembershipRlweQueryRequest() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.PrivateMembershipRlweQueryRequest)
  SharedDtor();
}

void PrivateMembershipRlweQueryRequest::SharedDtor() {
}

void PrivateMembershipRlweQueryRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PrivateMembershipRlweQueryRequest& PrivateMembershipRlweQueryRequest::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PrivateMembershipRlweQueryRequest_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void PrivateMembershipRlweQueryRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.PrivateMembershipRlweQueryRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  queries_.Clear();
  ::memset(&key_version_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&use_case_) -
      reinterpret_cast<char*>(&key_version_)) + sizeof(use_case_));
  _internal_metadata_.Clear();
}

const char* PrivateMembershipRlweQueryRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .private_membership.rlwe.PrivateMembershipRlweQuery queries = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_queries(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // .private_membership.rlwe.RlweUseCase use_case = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          _internal_set_use_case(static_cast<::private_membership::rlwe::RlweUseCase>(val));
        } else goto handle_unusual;
        continue;
      // int64 key_version = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          key_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* PrivateMembershipRlweQueryRequest::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.PrivateMembershipRlweQueryRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .private_membership.rlwe.PrivateMembershipRlweQuery queries = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_queries_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_queries(i), target, stream);
  }

  // .private_membership.rlwe.RlweUseCase use_case = 2;
  if (this->use_case() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_use_case(), target);
  }

  // int64 key_version = 3;
  if (this->key_version() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_key_version(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.PrivateMembershipRlweQueryRequest)
  return target;
}

size_t PrivateMembershipRlweQueryRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.PrivateMembershipRlweQueryRequest)
  size_t total_size = 0;

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

  // repeated .private_membership.rlwe.PrivateMembershipRlweQuery queries = 1;
  total_size += 1UL * this->_internal_queries_size();
  for (const auto& msg : this->queries_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // int64 key_version = 3;
  if (this->key_version() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
        this->_internal_key_version());
  }

  // .private_membership.rlwe.RlweUseCase use_case = 2;
  if (this->use_case() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_use_case());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void PrivateMembershipRlweQueryRequest::MergeFrom(const PrivateMembershipRlweQueryRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.PrivateMembershipRlweQueryRequest)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  queries_.MergeFrom(from.queries_);
  if (from.key_version() != 0) {
    _internal_set_key_version(from._internal_key_version());
  }
  if (from.use_case() != 0) {
    _internal_set_use_case(from._internal_use_case());
  }
}

void PrivateMembershipRlweQueryRequest::CopyFrom(const PrivateMembershipRlweQueryRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.PrivateMembershipRlweQueryRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PrivateMembershipRlweQueryRequest::InternalSwap(PrivateMembershipRlweQueryRequest* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  queries_.InternalSwap(&other->queries_);
  swap(key_version_, other->key_version_);
  swap(use_case_, other->use_case_);
}

std::string PrivateMembershipRlweQueryRequest::GetTypeName() const {
  return "private_membership.rlwe.PrivateMembershipRlweQueryRequest";
}


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

void PrivateMembershipRlweQueryResponse::InitAsDefaultInstance() {
}
class PrivateMembershipRlweQueryResponse::_Internal {
 public:
};

PrivateMembershipRlweQueryResponse::PrivateMembershipRlweQueryResponse()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.PrivateMembershipRlweQueryResponse)
}
PrivateMembershipRlweQueryResponse::PrivateMembershipRlweQueryResponse(const PrivateMembershipRlweQueryResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      pir_responses_(from.pir_responses_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.PrivateMembershipRlweQueryResponse)
}

void PrivateMembershipRlweQueryResponse::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PrivateMembershipRlweQueryResponse_private_5fmembership_5frlwe_2eproto.base);
}

PrivateMembershipRlweQueryResponse::~PrivateMembershipRlweQueryResponse() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.PrivateMembershipRlweQueryResponse)
  SharedDtor();
}

void PrivateMembershipRlweQueryResponse::SharedDtor() {
}

void PrivateMembershipRlweQueryResponse::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PrivateMembershipRlweQueryResponse& PrivateMembershipRlweQueryResponse::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PrivateMembershipRlweQueryResponse_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void PrivateMembershipRlweQueryResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.PrivateMembershipRlweQueryResponse)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  pir_responses_.Clear();
  _internal_metadata_.Clear();
}

const char* PrivateMembershipRlweQueryResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .private_membership.rlwe.PrivateMembershipRlwePirResponse pir_responses = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_pir_responses(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* PrivateMembershipRlweQueryResponse::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.PrivateMembershipRlweQueryResponse)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .private_membership.rlwe.PrivateMembershipRlwePirResponse pir_responses = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_pir_responses_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_pir_responses(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.PrivateMembershipRlweQueryResponse)
  return target;
}

size_t PrivateMembershipRlweQueryResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.PrivateMembershipRlweQueryResponse)
  size_t total_size = 0;

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

  // repeated .private_membership.rlwe.PrivateMembershipRlwePirResponse pir_responses = 1;
  total_size += 1UL * this->_internal_pir_responses_size();
  for (const auto& msg : this->pir_responses_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void PrivateMembershipRlweQueryResponse::MergeFrom(const PrivateMembershipRlweQueryResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.PrivateMembershipRlweQueryResponse)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  pir_responses_.MergeFrom(from.pir_responses_);
}

void PrivateMembershipRlweQueryResponse::CopyFrom(const PrivateMembershipRlweQueryResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.PrivateMembershipRlweQueryResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string PrivateMembershipRlweQueryResponse::GetTypeName() const {
  return "private_membership.rlwe.PrivateMembershipRlweQueryResponse";
}


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

void RlwePlaintextId::InitAsDefaultInstance() {
}
class RlwePlaintextId::_Internal {
 public:
};

RlwePlaintextId::RlwePlaintextId()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.RlwePlaintextId)
}
RlwePlaintextId::RlwePlaintextId(const RlwePlaintextId& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  non_sensitive_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_non_sensitive_id().empty()) {
    non_sensitive_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.non_sensitive_id_);
  }
  sensitive_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_sensitive_id().empty()) {
    sensitive_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.sensitive_id_);
  }
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.RlwePlaintextId)
}

void RlwePlaintextId::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RlwePlaintextId_private_5fmembership_5frlwe_2eproto.base);
  non_sensitive_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  sensitive_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

RlwePlaintextId::~RlwePlaintextId() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.RlwePlaintextId)
  SharedDtor();
}

void RlwePlaintextId::SharedDtor() {
  non_sensitive_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  sensitive_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void RlwePlaintextId::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const RlwePlaintextId& RlwePlaintextId::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RlwePlaintextId_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void RlwePlaintextId::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.RlwePlaintextId)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  non_sensitive_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  sensitive_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _internal_metadata_.Clear();
}

const char* RlwePlaintextId::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string non_sensitive_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_non_sensitive_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string sensitive_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_sensitive_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RlwePlaintextId::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.RlwePlaintextId)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string non_sensitive_id = 1;
  if (this->non_sensitive_id().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_non_sensitive_id().data(), static_cast<int>(this->_internal_non_sensitive_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "private_membership.rlwe.RlwePlaintextId.non_sensitive_id");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_non_sensitive_id(), target);
  }

  // string sensitive_id = 2;
  if (this->sensitive_id().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_sensitive_id().data(), static_cast<int>(this->_internal_sensitive_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "private_membership.rlwe.RlwePlaintextId.sensitive_id");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_sensitive_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.RlwePlaintextId)
  return target;
}

size_t RlwePlaintextId::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.RlwePlaintextId)
  size_t total_size = 0;

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

  // string non_sensitive_id = 1;
  if (this->non_sensitive_id().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_non_sensitive_id());
  }

  // string sensitive_id = 2;
  if (this->sensitive_id().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_sensitive_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void RlwePlaintextId::MergeFrom(const RlwePlaintextId& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.RlwePlaintextId)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.non_sensitive_id().size() > 0) {

    non_sensitive_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.non_sensitive_id_);
  }
  if (from.sensitive_id().size() > 0) {

    sensitive_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.sensitive_id_);
  }
}

void RlwePlaintextId::CopyFrom(const RlwePlaintextId& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.RlwePlaintextId)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void RlwePlaintextId::InternalSwap(RlwePlaintextId* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  non_sensitive_id_.Swap(&other->non_sensitive_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  sensitive_id_.Swap(&other->sensitive_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

std::string RlwePlaintextId::GetTypeName() const {
  return "private_membership.rlwe.RlwePlaintextId";
}


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

void HashedBucketsParameters::InitAsDefaultInstance() {
}
class HashedBucketsParameters::_Internal {
 public:
};

HashedBucketsParameters::HashedBucketsParameters()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.HashedBucketsParameters)
}
HashedBucketsParameters::HashedBucketsParameters(const HashedBucketsParameters& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&hashed_bucket_id_length_, &from.hashed_bucket_id_length_,
    static_cast<size_t>(reinterpret_cast<char*>(&non_sensitive_id_hash_type_) -
    reinterpret_cast<char*>(&hashed_bucket_id_length_)) + sizeof(non_sensitive_id_hash_type_));
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.HashedBucketsParameters)
}

void HashedBucketsParameters::SharedCtor() {
  ::memset(&hashed_bucket_id_length_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&non_sensitive_id_hash_type_) -
      reinterpret_cast<char*>(&hashed_bucket_id_length_)) + sizeof(non_sensitive_id_hash_type_));
}

HashedBucketsParameters::~HashedBucketsParameters() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.HashedBucketsParameters)
  SharedDtor();
}

void HashedBucketsParameters::SharedDtor() {
}

void HashedBucketsParameters::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const HashedBucketsParameters& HashedBucketsParameters::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HashedBucketsParameters_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void HashedBucketsParameters::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.HashedBucketsParameters)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&hashed_bucket_id_length_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&non_sensitive_id_hash_type_) -
      reinterpret_cast<char*>(&hashed_bucket_id_length_)) + sizeof(non_sensitive_id_hash_type_));
  _internal_metadata_.Clear();
}

const char* HashedBucketsParameters::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 hashed_bucket_id_length = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          hashed_bucket_id_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .private_membership.HashType non_sensitive_id_hash_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          _internal_set_non_sensitive_id_hash_type(static_cast<::private_membership::HashType>(val));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* HashedBucketsParameters::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.HashedBucketsParameters)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 hashed_bucket_id_length = 1;
  if (this->hashed_bucket_id_length() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_hashed_bucket_id_length(), target);
  }

  // .private_membership.HashType non_sensitive_id_hash_type = 2;
  if (this->non_sensitive_id_hash_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_non_sensitive_id_hash_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.HashedBucketsParameters)
  return target;
}

size_t HashedBucketsParameters::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.HashedBucketsParameters)
  size_t total_size = 0;

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

  // int32 hashed_bucket_id_length = 1;
  if (this->hashed_bucket_id_length() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_hashed_bucket_id_length());
  }

  // .private_membership.HashType non_sensitive_id_hash_type = 2;
  if (this->non_sensitive_id_hash_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_non_sensitive_id_hash_type());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void HashedBucketsParameters::MergeFrom(const HashedBucketsParameters& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.HashedBucketsParameters)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.hashed_bucket_id_length() != 0) {
    _internal_set_hashed_bucket_id_length(from._internal_hashed_bucket_id_length());
  }
  if (from.non_sensitive_id_hash_type() != 0) {
    _internal_set_non_sensitive_id_hash_type(from._internal_non_sensitive_id_hash_type());
  }
}

void HashedBucketsParameters::CopyFrom(const HashedBucketsParameters& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.HashedBucketsParameters)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void HashedBucketsParameters::InternalSwap(HashedBucketsParameters* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(hashed_bucket_id_length_, other->hashed_bucket_id_length_);
  swap(non_sensitive_id_hash_type_, other->non_sensitive_id_hash_type_);
}

std::string HashedBucketsParameters::GetTypeName() const {
  return "private_membership.rlwe.HashedBucketsParameters";
}


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

void EncryptedBucketsParameters::InitAsDefaultInstance() {
}
class EncryptedBucketsParameters::_Internal {
 public:
};

EncryptedBucketsParameters::EncryptedBucketsParameters()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.EncryptedBucketsParameters)
}
EncryptedBucketsParameters::EncryptedBucketsParameters(const EncryptedBucketsParameters& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&encrypted_bucket_id_length_, &from.encrypted_bucket_id_length_,
    static_cast<size_t>(reinterpret_cast<char*>(&sensitive_id_hash_type_) -
    reinterpret_cast<char*>(&encrypted_bucket_id_length_)) + sizeof(sensitive_id_hash_type_));
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.EncryptedBucketsParameters)
}

void EncryptedBucketsParameters::SharedCtor() {
  ::memset(&encrypted_bucket_id_length_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&sensitive_id_hash_type_) -
      reinterpret_cast<char*>(&encrypted_bucket_id_length_)) + sizeof(sensitive_id_hash_type_));
}

EncryptedBucketsParameters::~EncryptedBucketsParameters() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.EncryptedBucketsParameters)
  SharedDtor();
}

void EncryptedBucketsParameters::SharedDtor() {
}

void EncryptedBucketsParameters::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const EncryptedBucketsParameters& EncryptedBucketsParameters::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_EncryptedBucketsParameters_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void EncryptedBucketsParameters::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.EncryptedBucketsParameters)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&encrypted_bucket_id_length_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&sensitive_id_hash_type_) -
      reinterpret_cast<char*>(&encrypted_bucket_id_length_)) + sizeof(sensitive_id_hash_type_));
  _internal_metadata_.Clear();
}

const char* EncryptedBucketsParameters::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int32 encrypted_bucket_id_length = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          encrypted_bucket_id_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .private_membership.EncryptedBucketHashType sensitive_id_hash_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          _internal_set_sensitive_id_hash_type(static_cast<::private_membership::EncryptedBucketHashType>(val));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* EncryptedBucketsParameters::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.EncryptedBucketsParameters)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 encrypted_bucket_id_length = 1;
  if (this->encrypted_bucket_id_length() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_encrypted_bucket_id_length(), target);
  }

  // .private_membership.EncryptedBucketHashType sensitive_id_hash_type = 2;
  if (this->sensitive_id_hash_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_sensitive_id_hash_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.EncryptedBucketsParameters)
  return target;
}

size_t EncryptedBucketsParameters::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.EncryptedBucketsParameters)
  size_t total_size = 0;

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

  // int32 encrypted_bucket_id_length = 1;
  if (this->encrypted_bucket_id_length() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_encrypted_bucket_id_length());
  }

  // .private_membership.EncryptedBucketHashType sensitive_id_hash_type = 2;
  if (this->sensitive_id_hash_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sensitive_id_hash_type());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void EncryptedBucketsParameters::MergeFrom(const EncryptedBucketsParameters& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.EncryptedBucketsParameters)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.encrypted_bucket_id_length() != 0) {
    _internal_set_encrypted_bucket_id_length(from._internal_encrypted_bucket_id_length());
  }
  if (from.sensitive_id_hash_type() != 0) {
    _internal_set_sensitive_id_hash_type(from._internal_sensitive_id_hash_type());
  }
}

void EncryptedBucketsParameters::CopyFrom(const EncryptedBucketsParameters& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.EncryptedBucketsParameters)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void EncryptedBucketsParameters::InternalSwap(EncryptedBucketsParameters* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(encrypted_bucket_id_length_, other->encrypted_bucket_id_length_);
  swap(sensitive_id_hash_type_, other->sensitive_id_hash_type_);
}

std::string EncryptedBucketsParameters::GetTypeName() const {
  return "private_membership.rlwe.EncryptedBucketsParameters";
}


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

void RlweParameters::InitAsDefaultInstance() {
}
class RlweParameters::_Internal {
 public:
};

RlweParameters::RlweParameters()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.RlweParameters)
}
RlweParameters::RlweParameters(const RlweParameters& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      modulus_(from.modulus_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&log_degree_, &from.log_degree_,
    static_cast<size_t>(reinterpret_cast<char*>(&levels_of_recursion_) -
    reinterpret_cast<char*>(&log_degree_)) + sizeof(levels_of_recursion_));
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.RlweParameters)
}

void RlweParameters::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RlweParameters_private_5fmembership_5frlwe_2eproto.base);
  ::memset(&log_degree_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&levels_of_recursion_) -
      reinterpret_cast<char*>(&log_degree_)) + sizeof(levels_of_recursion_));
}

RlweParameters::~RlweParameters() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.RlweParameters)
  SharedDtor();
}

void RlweParameters::SharedDtor() {
}

void RlweParameters::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const RlweParameters& RlweParameters::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RlweParameters_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void RlweParameters::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.RlweParameters)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  modulus_.Clear();
  ::memset(&log_degree_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&levels_of_recursion_) -
      reinterpret_cast<char*>(&log_degree_)) + sizeof(levels_of_recursion_));
  _internal_metadata_.Clear();
}

const char* RlweParameters::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .private_membership.rlwe.Uint128 modulus = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_modulus(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // int32 log_degree = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          log_degree_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 log_t = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          log_t_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 variance = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          variance_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 levels_of_recursion = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          levels_of_recursion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RlweParameters::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.RlweParameters)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .private_membership.rlwe.Uint128 modulus = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_modulus_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_modulus(i), target, stream);
  }

  // int32 log_degree = 2;
  if (this->log_degree() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_log_degree(), target);
  }

  // int32 log_t = 3;
  if (this->log_t() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_log_t(), target);
  }

  // int32 variance = 4;
  if (this->variance() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_variance(), target);
  }

  // int32 levels_of_recursion = 5;
  if (this->levels_of_recursion() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_levels_of_recursion(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.RlweParameters)
  return target;
}

size_t RlweParameters::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.RlweParameters)
  size_t total_size = 0;

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

  // repeated .private_membership.rlwe.Uint128 modulus = 1;
  total_size += 1UL * this->_internal_modulus_size();
  for (const auto& msg : this->modulus_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // int32 log_degree = 2;
  if (this->log_degree() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_log_degree());
  }

  // int32 log_t = 3;
  if (this->log_t() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_log_t());
  }

  // int32 variance = 4;
  if (this->variance() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_variance());
  }

  // int32 levels_of_recursion = 5;
  if (this->levels_of_recursion() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_levels_of_recursion());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void RlweParameters::MergeFrom(const RlweParameters& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.RlweParameters)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  modulus_.MergeFrom(from.modulus_);
  if (from.log_degree() != 0) {
    _internal_set_log_degree(from._internal_log_degree());
  }
  if (from.log_t() != 0) {
    _internal_set_log_t(from._internal_log_t());
  }
  if (from.variance() != 0) {
    _internal_set_variance(from._internal_variance());
  }
  if (from.levels_of_recursion() != 0) {
    _internal_set_levels_of_recursion(from._internal_levels_of_recursion());
  }
}

void RlweParameters::CopyFrom(const RlweParameters& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.RlweParameters)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void RlweParameters::InternalSwap(RlweParameters* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  modulus_.InternalSwap(&other->modulus_);
  swap(log_degree_, other->log_degree_);
  swap(log_t_, other->log_t_);
  swap(variance_, other->variance_);
  swap(levels_of_recursion_, other->levels_of_recursion_);
}

std::string RlweParameters::GetTypeName() const {
  return "private_membership.rlwe.RlweParameters";
}


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

void Uint128::InitAsDefaultInstance() {
}
class Uint128::_Internal {
 public:
};

Uint128::Uint128()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.Uint128)
}
Uint128::Uint128(const Uint128& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&lo_, &from.lo_,
    static_cast<size_t>(reinterpret_cast<char*>(&hi_) -
    reinterpret_cast<char*>(&lo_)) + sizeof(hi_));
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.Uint128)
}

void Uint128::SharedCtor() {
  ::memset(&lo_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&hi_) -
      reinterpret_cast<char*>(&lo_)) + sizeof(hi_));
}

Uint128::~Uint128() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.Uint128)
  SharedDtor();
}

void Uint128::SharedDtor() {
}

void Uint128::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Uint128& Uint128::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Uint128_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void Uint128::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.Uint128)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&lo_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&hi_) -
      reinterpret_cast<char*>(&lo_)) + sizeof(hi_));
  _internal_metadata_.Clear();
}

const char* Uint128::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // uint64 lo = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          lo_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint64 hi = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          hi_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Uint128::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.Uint128)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // uint64 lo = 1;
  if (this->lo() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_lo(), target);
  }

  // uint64 hi = 2;
  if (this->hi() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->_internal_hi(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.Uint128)
  return target;
}

size_t Uint128::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.Uint128)
  size_t total_size = 0;

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

  // uint64 lo = 1;
  if (this->lo() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->_internal_lo());
  }

  // uint64 hi = 2;
  if (this->hi() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->_internal_hi());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void Uint128::MergeFrom(const Uint128& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.Uint128)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.lo() != 0) {
    _internal_set_lo(from._internal_lo());
  }
  if (from.hi() != 0) {
    _internal_set_hi(from._internal_hi());
  }
}

void Uint128::CopyFrom(const Uint128& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.Uint128)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void Uint128::InternalSwap(Uint128* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(lo_, other->lo_);
  swap(hi_, other->hi_);
}

std::string Uint128::GetTypeName() const {
  return "private_membership.rlwe.Uint128";
}


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

void PrivateMembershipRlweQuery_HashedBucketId::InitAsDefaultInstance() {
}
class PrivateMembershipRlweQuery_HashedBucketId::_Internal {
 public:
};

PrivateMembershipRlweQuery_HashedBucketId::PrivateMembershipRlweQuery_HashedBucketId()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId)
}
PrivateMembershipRlweQuery_HashedBucketId::PrivateMembershipRlweQuery_HashedBucketId(const PrivateMembershipRlweQuery_HashedBucketId& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  hashed_bucket_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_hashed_bucket_id().empty()) {
    hashed_bucket_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.hashed_bucket_id_);
  }
  bit_length_ = from.bit_length_;
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId)
}

void PrivateMembershipRlweQuery_HashedBucketId::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PrivateMembershipRlweQuery_HashedBucketId_private_5fmembership_5frlwe_2eproto.base);
  hashed_bucket_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  bit_length_ = 0;
}

PrivateMembershipRlweQuery_HashedBucketId::~PrivateMembershipRlweQuery_HashedBucketId() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId)
  SharedDtor();
}

void PrivateMembershipRlweQuery_HashedBucketId::SharedDtor() {
  hashed_bucket_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void PrivateMembershipRlweQuery_HashedBucketId::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PrivateMembershipRlweQuery_HashedBucketId& PrivateMembershipRlweQuery_HashedBucketId::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PrivateMembershipRlweQuery_HashedBucketId_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void PrivateMembershipRlweQuery_HashedBucketId::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  hashed_bucket_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  bit_length_ = 0;
  _internal_metadata_.Clear();
}

const char* PrivateMembershipRlweQuery_HashedBucketId::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // bytes hashed_bucket_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_hashed_bucket_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 bit_length = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          bit_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* PrivateMembershipRlweQuery_HashedBucketId::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bytes hashed_bucket_id = 1;
  if (this->hashed_bucket_id().size() > 0) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_hashed_bucket_id(), target);
  }

  // int32 bit_length = 2;
  if (this->bit_length() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_bit_length(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId)
  return target;
}

size_t PrivateMembershipRlweQuery_HashedBucketId::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId)
  size_t total_size = 0;

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

  // bytes hashed_bucket_id = 1;
  if (this->hashed_bucket_id().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_hashed_bucket_id());
  }

  // int32 bit_length = 2;
  if (this->bit_length() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_bit_length());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void PrivateMembershipRlweQuery_HashedBucketId::MergeFrom(const PrivateMembershipRlweQuery_HashedBucketId& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.hashed_bucket_id().size() > 0) {

    hashed_bucket_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.hashed_bucket_id_);
  }
  if (from.bit_length() != 0) {
    _internal_set_bit_length(from._internal_bit_length());
  }
}

void PrivateMembershipRlweQuery_HashedBucketId::CopyFrom(const PrivateMembershipRlweQuery_HashedBucketId& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PrivateMembershipRlweQuery_HashedBucketId::InternalSwap(PrivateMembershipRlweQuery_HashedBucketId* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  hashed_bucket_id_.Swap(&other->hashed_bucket_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(bit_length_, other->bit_length_);
}

std::string PrivateMembershipRlweQuery_HashedBucketId::GetTypeName() const {
  return "private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId";
}


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

void PrivateMembershipRlweQuery::InitAsDefaultInstance() {
  ::private_membership::rlwe::_PrivateMembershipRlweQuery_default_instance_._instance.get_mutable()->pir_request_ = const_cast< ::private_membership::rlwe::PirRequest*>(
      ::private_membership::rlwe::PirRequest::internal_default_instance());
  ::private_membership::rlwe::_PrivateMembershipRlweQuery_default_instance_._instance.get_mutable()->hashed_bucket_id_ = const_cast< ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId*>(
      ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId::internal_default_instance());
}
class PrivateMembershipRlweQuery::_Internal {
 public:
  static const ::private_membership::rlwe::PirRequest& pir_request(const PrivateMembershipRlweQuery* msg);
  static const ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId& hashed_bucket_id(const PrivateMembershipRlweQuery* msg);
};

const ::private_membership::rlwe::PirRequest&
PrivateMembershipRlweQuery::_Internal::pir_request(const PrivateMembershipRlweQuery* msg) {
  return *msg->pir_request_;
}
const ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId&
PrivateMembershipRlweQuery::_Internal::hashed_bucket_id(const PrivateMembershipRlweQuery* msg) {
  return *msg->hashed_bucket_id_;
}
PrivateMembershipRlweQuery::PrivateMembershipRlweQuery()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.PrivateMembershipRlweQuery)
}
PrivateMembershipRlweQuery::PrivateMembershipRlweQuery(const PrivateMembershipRlweQuery& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  queried_encrypted_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_queried_encrypted_id().empty()) {
    queried_encrypted_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.queried_encrypted_id_);
  }
  if (from._internal_has_pir_request()) {
    pir_request_ = new ::private_membership::rlwe::PirRequest(*from.pir_request_);
  } else {
    pir_request_ = nullptr;
  }
  if (from._internal_has_hashed_bucket_id()) {
    hashed_bucket_id_ = new ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId(*from.hashed_bucket_id_);
  } else {
    hashed_bucket_id_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.PrivateMembershipRlweQuery)
}

void PrivateMembershipRlweQuery::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PrivateMembershipRlweQuery_private_5fmembership_5frlwe_2eproto.base);
  queried_encrypted_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&pir_request_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&hashed_bucket_id_) -
      reinterpret_cast<char*>(&pir_request_)) + sizeof(hashed_bucket_id_));
}

PrivateMembershipRlweQuery::~PrivateMembershipRlweQuery() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.PrivateMembershipRlweQuery)
  SharedDtor();
}

void PrivateMembershipRlweQuery::SharedDtor() {
  queried_encrypted_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete pir_request_;
  if (this != internal_default_instance()) delete hashed_bucket_id_;
}

void PrivateMembershipRlweQuery::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PrivateMembershipRlweQuery& PrivateMembershipRlweQuery::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PrivateMembershipRlweQuery_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void PrivateMembershipRlweQuery::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.PrivateMembershipRlweQuery)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  queried_encrypted_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (GetArenaNoVirtual() == nullptr && pir_request_ != nullptr) {
    delete pir_request_;
  }
  pir_request_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && hashed_bucket_id_ != nullptr) {
    delete hashed_bucket_id_;
  }
  hashed_bucket_id_ = nullptr;
  _internal_metadata_.Clear();
}

const char* PrivateMembershipRlweQuery::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // bytes queried_encrypted_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_queried_encrypted_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .private_membership.rlwe.PirRequest pir_request = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_pir_request(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId hashed_bucket_id = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_hashed_bucket_id(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* PrivateMembershipRlweQuery::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.PrivateMembershipRlweQuery)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bytes queried_encrypted_id = 1;
  if (this->queried_encrypted_id().size() > 0) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_queried_encrypted_id(), target);
  }

  // .private_membership.rlwe.PirRequest pir_request = 2;
  if (this->has_pir_request()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::pir_request(this), target, stream);
  }

  // .private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId hashed_bucket_id = 3;
  if (this->has_hashed_bucket_id()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::hashed_bucket_id(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.PrivateMembershipRlweQuery)
  return target;
}

size_t PrivateMembershipRlweQuery::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.PrivateMembershipRlweQuery)
  size_t total_size = 0;

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

  // bytes queried_encrypted_id = 1;
  if (this->queried_encrypted_id().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_queried_encrypted_id());
  }

  // .private_membership.rlwe.PirRequest pir_request = 2;
  if (this->has_pir_request()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *pir_request_);
  }

  // .private_membership.rlwe.PrivateMembershipRlweQuery.HashedBucketId hashed_bucket_id = 3;
  if (this->has_hashed_bucket_id()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *hashed_bucket_id_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void PrivateMembershipRlweQuery::MergeFrom(const PrivateMembershipRlweQuery& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.PrivateMembershipRlweQuery)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.queried_encrypted_id().size() > 0) {

    queried_encrypted_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.queried_encrypted_id_);
  }
  if (from.has_pir_request()) {
    _internal_mutable_pir_request()->::private_membership::rlwe::PirRequest::MergeFrom(from._internal_pir_request());
  }
  if (from.has_hashed_bucket_id()) {
    _internal_mutable_hashed_bucket_id()->::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId::MergeFrom(from._internal_hashed_bucket_id());
  }
}

void PrivateMembershipRlweQuery::CopyFrom(const PrivateMembershipRlweQuery& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.PrivateMembershipRlweQuery)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PrivateMembershipRlweQuery::InternalSwap(PrivateMembershipRlweQuery* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  queried_encrypted_id_.Swap(&other->queried_encrypted_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(pir_request_, other->pir_request_);
  swap(hashed_bucket_id_, other->hashed_bucket_id_);
}

std::string PrivateMembershipRlweQuery::GetTypeName() const {
  return "private_membership.rlwe.PrivateMembershipRlweQuery";
}


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

void PrivateMembershipRlwePirResponse::InitAsDefaultInstance() {
  ::private_membership::rlwe::_PrivateMembershipRlwePirResponse_default_instance_._instance.get_mutable()->pir_response_ = const_cast< ::private_membership::rlwe::PirResponse*>(
      ::private_membership::rlwe::PirResponse::internal_default_instance());
}
class PrivateMembershipRlwePirResponse::_Internal {
 public:
  static const ::private_membership::rlwe::PirResponse& pir_response(const PrivateMembershipRlwePirResponse* msg);
};

const ::private_membership::rlwe::PirResponse&
PrivateMembershipRlwePirResponse::_Internal::pir_response(const PrivateMembershipRlwePirResponse* msg) {
  return *msg->pir_response_;
}
PrivateMembershipRlwePirResponse::PrivateMembershipRlwePirResponse()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.PrivateMembershipRlwePirResponse)
}
PrivateMembershipRlwePirResponse::PrivateMembershipRlwePirResponse(const PrivateMembershipRlwePirResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  queried_encrypted_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_queried_encrypted_id().empty()) {
    queried_encrypted_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.queried_encrypted_id_);
  }
  if (from._internal_has_pir_response()) {
    pir_response_ = new ::private_membership::rlwe::PirResponse(*from.pir_response_);
  } else {
    pir_response_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.PrivateMembershipRlwePirResponse)
}

void PrivateMembershipRlwePirResponse::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PrivateMembershipRlwePirResponse_private_5fmembership_5frlwe_2eproto.base);
  queried_encrypted_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  pir_response_ = nullptr;
}

PrivateMembershipRlwePirResponse::~PrivateMembershipRlwePirResponse() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.PrivateMembershipRlwePirResponse)
  SharedDtor();
}

void PrivateMembershipRlwePirResponse::SharedDtor() {
  queried_encrypted_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete pir_response_;
}

void PrivateMembershipRlwePirResponse::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PrivateMembershipRlwePirResponse& PrivateMembershipRlwePirResponse::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PrivateMembershipRlwePirResponse_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void PrivateMembershipRlwePirResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.PrivateMembershipRlwePirResponse)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  queried_encrypted_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (GetArenaNoVirtual() == nullptr && pir_response_ != nullptr) {
    delete pir_response_;
  }
  pir_response_ = nullptr;
  _internal_metadata_.Clear();
}

const char* PrivateMembershipRlwePirResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // bytes queried_encrypted_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_queried_encrypted_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .private_membership.rlwe.PirResponse pir_response = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_pir_response(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* PrivateMembershipRlwePirResponse::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.PrivateMembershipRlwePirResponse)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bytes queried_encrypted_id = 1;
  if (this->queried_encrypted_id().size() > 0) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_queried_encrypted_id(), target);
  }

  // .private_membership.rlwe.PirResponse pir_response = 2;
  if (this->has_pir_response()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::pir_response(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.PrivateMembershipRlwePirResponse)
  return target;
}

size_t PrivateMembershipRlwePirResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.PrivateMembershipRlwePirResponse)
  size_t total_size = 0;

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

  // bytes queried_encrypted_id = 1;
  if (this->queried_encrypted_id().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_queried_encrypted_id());
  }

  // .private_membership.rlwe.PirResponse pir_response = 2;
  if (this->has_pir_response()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *pir_response_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void PrivateMembershipRlwePirResponse::MergeFrom(const PrivateMembershipRlwePirResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.PrivateMembershipRlwePirResponse)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.queried_encrypted_id().size() > 0) {

    queried_encrypted_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.queried_encrypted_id_);
  }
  if (from.has_pir_response()) {
    _internal_mutable_pir_response()->::private_membership::rlwe::PirResponse::MergeFrom(from._internal_pir_response());
  }
}

void PrivateMembershipRlwePirResponse::CopyFrom(const PrivateMembershipRlwePirResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.PrivateMembershipRlwePirResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PrivateMembershipRlwePirResponse::InternalSwap(PrivateMembershipRlwePirResponse* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  queried_encrypted_id_.Swap(&other->queried_encrypted_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(pir_response_, other->pir_response_);
}

std::string PrivateMembershipRlwePirResponse::GetTypeName() const {
  return "private_membership.rlwe.PrivateMembershipRlwePirResponse";
}


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

void PirRequest::InitAsDefaultInstance() {
}
class PirRequest::_Internal {
 public:
};

void PirRequest::clear_request() {
  request_.Clear();
}
PirRequest::PirRequest()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.PirRequest)
}
PirRequest::PirRequest(const PirRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      request_(from.request_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  prng_seed_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_prng_seed().empty()) {
    prng_seed_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.prng_seed_);
  }
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.PirRequest)
}

void PirRequest::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PirRequest_private_5fmembership_5frlwe_2eproto.base);
  prng_seed_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

PirRequest::~PirRequest() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.PirRequest)
  SharedDtor();
}

void PirRequest::SharedDtor() {
  prng_seed_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void PirRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PirRequest& PirRequest::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PirRequest_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void PirRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.PirRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  request_.Clear();
  prng_seed_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _internal_metadata_.Clear();
}

const char* PirRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .rlwe.SerializedNttPolynomial request = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_request(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // bytes prng_seed = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_prng_seed();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* PirRequest::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.PirRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .rlwe.SerializedNttPolynomial request = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_request_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_request(i), target, stream);
  }

  // bytes prng_seed = 2;
  if (this->prng_seed().size() > 0) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_prng_seed(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.PirRequest)
  return target;
}

size_t PirRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.PirRequest)
  size_t total_size = 0;

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

  // repeated .rlwe.SerializedNttPolynomial request = 1;
  total_size += 1UL * this->_internal_request_size();
  for (const auto& msg : this->request_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // bytes prng_seed = 2;
  if (this->prng_seed().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_prng_seed());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void PirRequest::MergeFrom(const PirRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.PirRequest)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  request_.MergeFrom(from.request_);
  if (from.prng_seed().size() > 0) {

    prng_seed_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.prng_seed_);
  }
}

void PirRequest::CopyFrom(const PirRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.PirRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PirRequest::InternalSwap(PirRequest* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  request_.InternalSwap(&other->request_);
  prng_seed_.Swap(&other->prng_seed_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

std::string PirRequest::GetTypeName() const {
  return "private_membership.rlwe.PirRequest";
}


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

void PirResponse::InitAsDefaultInstance() {
}
class PirResponse::_Internal {
 public:
};

void PirResponse::clear_response() {
  response_.Clear();
}
PirResponse::PirResponse()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.PirResponse)
}
PirResponse::PirResponse(const PirResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      response_(from.response_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  plaintext_entry_size_ = from.plaintext_entry_size_;
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.PirResponse)
}

void PirResponse::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PirResponse_private_5fmembership_5frlwe_2eproto.base);
  plaintext_entry_size_ = 0;
}

PirResponse::~PirResponse() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.PirResponse)
  SharedDtor();
}

void PirResponse::SharedDtor() {
}

void PirResponse::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PirResponse& PirResponse::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PirResponse_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void PirResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.PirResponse)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  response_.Clear();
  plaintext_entry_size_ = 0;
  _internal_metadata_.Clear();
}

const char* PirResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .rlwe.SerializedSymmetricRlweCiphertext response = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_response(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // int32 plaintext_entry_size = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          plaintext_entry_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* PirResponse::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.PirResponse)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .rlwe.SerializedSymmetricRlweCiphertext response = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_response_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_response(i), target, stream);
  }

  // int32 plaintext_entry_size = 2;
  if (this->plaintext_entry_size() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_plaintext_entry_size(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.PirResponse)
  return target;
}

size_t PirResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.PirResponse)
  size_t total_size = 0;

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

  // repeated .rlwe.SerializedSymmetricRlweCiphertext response = 1;
  total_size += 1UL * this->_internal_response_size();
  for (const auto& msg : this->response_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // int32 plaintext_entry_size = 2;
  if (this->plaintext_entry_size() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_plaintext_entry_size());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void PirResponse::MergeFrom(const PirResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.PirResponse)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  response_.MergeFrom(from.response_);
  if (from.plaintext_entry_size() != 0) {
    _internal_set_plaintext_entry_size(from._internal_plaintext_entry_size());
  }
}

void PirResponse::CopyFrom(const PirResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.PirResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void PirResponse::InternalSwap(PirResponse* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  response_.InternalSwap(&other->response_);
  swap(plaintext_entry_size_, other->plaintext_entry_size_);
}

std::string PirResponse::GetTypeName() const {
  return "private_membership.rlwe.PirResponse";
}


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

void EncryptedBucket_EncryptedIdValuePair::InitAsDefaultInstance() {
}
class EncryptedBucket_EncryptedIdValuePair::_Internal {
 public:
};

EncryptedBucket_EncryptedIdValuePair::EncryptedBucket_EncryptedIdValuePair()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair)
}
EncryptedBucket_EncryptedIdValuePair::EncryptedBucket_EncryptedIdValuePair(const EncryptedBucket_EncryptedIdValuePair& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  encrypted_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_encrypted_id().empty()) {
    encrypted_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.encrypted_id_);
  }
  encrypted_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_encrypted_value().empty()) {
    encrypted_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.encrypted_value_);
  }
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair)
}

void EncryptedBucket_EncryptedIdValuePair::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EncryptedBucket_EncryptedIdValuePair_private_5fmembership_5frlwe_2eproto.base);
  encrypted_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  encrypted_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

EncryptedBucket_EncryptedIdValuePair::~EncryptedBucket_EncryptedIdValuePair() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair)
  SharedDtor();
}

void EncryptedBucket_EncryptedIdValuePair::SharedDtor() {
  encrypted_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  encrypted_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void EncryptedBucket_EncryptedIdValuePair::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const EncryptedBucket_EncryptedIdValuePair& EncryptedBucket_EncryptedIdValuePair::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_EncryptedBucket_EncryptedIdValuePair_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void EncryptedBucket_EncryptedIdValuePair::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  encrypted_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  encrypted_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _internal_metadata_.Clear();
}

const char* EncryptedBucket_EncryptedIdValuePair::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // bytes encrypted_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_encrypted_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bytes encrypted_value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_encrypted_value();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* EncryptedBucket_EncryptedIdValuePair::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bytes encrypted_id = 1;
  if (this->encrypted_id().size() > 0) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_encrypted_id(), target);
  }

  // bytes encrypted_value = 2;
  if (this->encrypted_value().size() > 0) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_encrypted_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair)
  return target;
}

size_t EncryptedBucket_EncryptedIdValuePair::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair)
  size_t total_size = 0;

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

  // bytes encrypted_id = 1;
  if (this->encrypted_id().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_encrypted_id());
  }

  // bytes encrypted_value = 2;
  if (this->encrypted_value().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_encrypted_value());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void EncryptedBucket_EncryptedIdValuePair::MergeFrom(const EncryptedBucket_EncryptedIdValuePair& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.encrypted_id().size() > 0) {

    encrypted_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.encrypted_id_);
  }
  if (from.encrypted_value().size() > 0) {

    encrypted_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.encrypted_value_);
  }
}

void EncryptedBucket_EncryptedIdValuePair::CopyFrom(const EncryptedBucket_EncryptedIdValuePair& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void EncryptedBucket_EncryptedIdValuePair::InternalSwap(EncryptedBucket_EncryptedIdValuePair* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  encrypted_id_.Swap(&other->encrypted_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  encrypted_value_.Swap(&other->encrypted_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

std::string EncryptedBucket_EncryptedIdValuePair::GetTypeName() const {
  return "private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair";
}


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

void EncryptedBucket::InitAsDefaultInstance() {
}
class EncryptedBucket::_Internal {
 public:
};

EncryptedBucket::EncryptedBucket()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.EncryptedBucket)
}
EncryptedBucket::EncryptedBucket(const EncryptedBucket& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      encrypted_id_value_pairs_(from.encrypted_id_value_pairs_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.EncryptedBucket)
}

void EncryptedBucket::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EncryptedBucket_private_5fmembership_5frlwe_2eproto.base);
}

EncryptedBucket::~EncryptedBucket() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.EncryptedBucket)
  SharedDtor();
}

void EncryptedBucket::SharedDtor() {
}

void EncryptedBucket::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const EncryptedBucket& EncryptedBucket::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_EncryptedBucket_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void EncryptedBucket::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.EncryptedBucket)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  encrypted_id_value_pairs_.Clear();
  _internal_metadata_.Clear();
}

const char* EncryptedBucket::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair encrypted_id_value_pairs = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_encrypted_id_value_pairs(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* EncryptedBucket::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.EncryptedBucket)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair encrypted_id_value_pairs = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_encrypted_id_value_pairs_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_encrypted_id_value_pairs(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.EncryptedBucket)
  return target;
}

size_t EncryptedBucket::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.EncryptedBucket)
  size_t total_size = 0;

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

  // repeated .private_membership.rlwe.EncryptedBucket.EncryptedIdValuePair encrypted_id_value_pairs = 1;
  total_size += 1UL * this->_internal_encrypted_id_value_pairs_size();
  for (const auto& msg : this->encrypted_id_value_pairs_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void EncryptedBucket::MergeFrom(const EncryptedBucket& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.EncryptedBucket)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  encrypted_id_value_pairs_.MergeFrom(from.encrypted_id_value_pairs_);
}

void EncryptedBucket::CopyFrom(const EncryptedBucket& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.EncryptedBucket)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string EncryptedBucket::GetTypeName() const {
  return "private_membership.rlwe.EncryptedBucket";
}


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

void RlweMembershipResponses_MembershipResponseEntry::InitAsDefaultInstance() {
  ::private_membership::rlwe::_RlweMembershipResponses_MembershipResponseEntry_default_instance_._instance.get_mutable()->plaintext_id_ = const_cast< ::private_membership::rlwe::RlwePlaintextId*>(
      ::private_membership::rlwe::RlwePlaintextId::internal_default_instance());
  ::private_membership::rlwe::_RlweMembershipResponses_MembershipResponseEntry_default_instance_._instance.get_mutable()->membership_response_ = const_cast< ::private_membership::MembershipResponse*>(
      ::private_membership::MembershipResponse::internal_default_instance());
}
class RlweMembershipResponses_MembershipResponseEntry::_Internal {
 public:
  static const ::private_membership::rlwe::RlwePlaintextId& plaintext_id(const RlweMembershipResponses_MembershipResponseEntry* msg);
  static const ::private_membership::MembershipResponse& membership_response(const RlweMembershipResponses_MembershipResponseEntry* msg);
};

const ::private_membership::rlwe::RlwePlaintextId&
RlweMembershipResponses_MembershipResponseEntry::_Internal::plaintext_id(const RlweMembershipResponses_MembershipResponseEntry* msg) {
  return *msg->plaintext_id_;
}
const ::private_membership::MembershipResponse&
RlweMembershipResponses_MembershipResponseEntry::_Internal::membership_response(const RlweMembershipResponses_MembershipResponseEntry* msg) {
  return *msg->membership_response_;
}
void RlweMembershipResponses_MembershipResponseEntry::clear_membership_response() {
  if (GetArenaNoVirtual() == nullptr && membership_response_ != nullptr) {
    delete membership_response_;
  }
  membership_response_ = nullptr;
}
RlweMembershipResponses_MembershipResponseEntry::RlweMembershipResponses_MembershipResponseEntry()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry)
}
RlweMembershipResponses_MembershipResponseEntry::RlweMembershipResponses_MembershipResponseEntry(const RlweMembershipResponses_MembershipResponseEntry& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_plaintext_id()) {
    plaintext_id_ = new ::private_membership::rlwe::RlwePlaintextId(*from.plaintext_id_);
  } else {
    plaintext_id_ = nullptr;
  }
  if (from._internal_has_membership_response()) {
    membership_response_ = new ::private_membership::MembershipResponse(*from.membership_response_);
  } else {
    membership_response_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry)
}

void RlweMembershipResponses_MembershipResponseEntry::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RlweMembershipResponses_MembershipResponseEntry_private_5fmembership_5frlwe_2eproto.base);
  ::memset(&plaintext_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&membership_response_) -
      reinterpret_cast<char*>(&plaintext_id_)) + sizeof(membership_response_));
}

RlweMembershipResponses_MembershipResponseEntry::~RlweMembershipResponses_MembershipResponseEntry() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry)
  SharedDtor();
}

void RlweMembershipResponses_MembershipResponseEntry::SharedDtor() {
  if (this != internal_default_instance()) delete plaintext_id_;
  if (this != internal_default_instance()) delete membership_response_;
}

void RlweMembershipResponses_MembershipResponseEntry::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const RlweMembershipResponses_MembershipResponseEntry& RlweMembershipResponses_MembershipResponseEntry::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RlweMembershipResponses_MembershipResponseEntry_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void RlweMembershipResponses_MembershipResponseEntry::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaNoVirtual() == nullptr && plaintext_id_ != nullptr) {
    delete plaintext_id_;
  }
  plaintext_id_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && membership_response_ != nullptr) {
    delete membership_response_;
  }
  membership_response_ = nullptr;
  _internal_metadata_.Clear();
}

const char* RlweMembershipResponses_MembershipResponseEntry::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .private_membership.rlwe.RlwePlaintextId plaintext_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_plaintext_id(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .private_membership.MembershipResponse membership_response = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_membership_response(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RlweMembershipResponses_MembershipResponseEntry::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .private_membership.rlwe.RlwePlaintextId plaintext_id = 1;
  if (this->has_plaintext_id()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::plaintext_id(this), target, stream);
  }

  // .private_membership.MembershipResponse membership_response = 2;
  if (this->has_membership_response()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::membership_response(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry)
  return target;
}

size_t RlweMembershipResponses_MembershipResponseEntry::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry)
  size_t total_size = 0;

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

  // .private_membership.rlwe.RlwePlaintextId plaintext_id = 1;
  if (this->has_plaintext_id()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *plaintext_id_);
  }

  // .private_membership.MembershipResponse membership_response = 2;
  if (this->has_membership_response()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *membership_response_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void RlweMembershipResponses_MembershipResponseEntry::MergeFrom(const RlweMembershipResponses_MembershipResponseEntry& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_plaintext_id()) {
    _internal_mutable_plaintext_id()->::private_membership::rlwe::RlwePlaintextId::MergeFrom(from._internal_plaintext_id());
  }
  if (from.has_membership_response()) {
    _internal_mutable_membership_response()->::private_membership::MembershipResponse::MergeFrom(from._internal_membership_response());
  }
}

void RlweMembershipResponses_MembershipResponseEntry::CopyFrom(const RlweMembershipResponses_MembershipResponseEntry& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void RlweMembershipResponses_MembershipResponseEntry::InternalSwap(RlweMembershipResponses_MembershipResponseEntry* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(plaintext_id_, other->plaintext_id_);
  swap(membership_response_, other->membership_response_);
}

std::string RlweMembershipResponses_MembershipResponseEntry::GetTypeName() const {
  return "private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry";
}


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

void RlweMembershipResponses::InitAsDefaultInstance() {
}
class RlweMembershipResponses::_Internal {
 public:
};

RlweMembershipResponses::RlweMembershipResponses()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.rlwe.RlweMembershipResponses)
}
RlweMembershipResponses::RlweMembershipResponses(const RlweMembershipResponses& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      membership_responses_(from.membership_responses_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:private_membership.rlwe.RlweMembershipResponses)
}

void RlweMembershipResponses::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RlweMembershipResponses_private_5fmembership_5frlwe_2eproto.base);
}

RlweMembershipResponses::~RlweMembershipResponses() {
  // @@protoc_insertion_point(destructor:private_membership.rlwe.RlweMembershipResponses)
  SharedDtor();
}

void RlweMembershipResponses::SharedDtor() {
}

void RlweMembershipResponses::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const RlweMembershipResponses& RlweMembershipResponses::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RlweMembershipResponses_private_5fmembership_5frlwe_2eproto.base);
  return *internal_default_instance();
}


void RlweMembershipResponses::Clear() {
// @@protoc_insertion_point(message_clear_start:private_membership.rlwe.RlweMembershipResponses)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  membership_responses_.Clear();
  _internal_metadata_.Clear();
}

const char* RlweMembershipResponses::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry membership_responses = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_membership_responses(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RlweMembershipResponses::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:private_membership.rlwe.RlweMembershipResponses)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry membership_responses = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_membership_responses_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_membership_responses(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.rlwe.RlweMembershipResponses)
  return target;
}

size_t RlweMembershipResponses::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:private_membership.rlwe.RlweMembershipResponses)
  size_t total_size = 0;

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

  // repeated .private_membership.rlwe.RlweMembershipResponses.MembershipResponseEntry membership_responses = 1;
  total_size += 1UL * this->_internal_membership_responses_size();
  for (const auto& msg : this->membership_responses_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields().size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void RlweMembershipResponses::MergeFrom(const RlweMembershipResponses& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:private_membership.rlwe.RlweMembershipResponses)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  membership_responses_.MergeFrom(from.membership_responses_);
}

void RlweMembershipResponses::CopyFrom(const RlweMembershipResponses& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:private_membership.rlwe.RlweMembershipResponses)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string RlweMembershipResponses::GetTypeName() const {
  return "private_membership.rlwe.RlweMembershipResponses";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace rlwe
}  // namespace private_membership
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::PrivateMembershipRlweOprfRequest* Arena::CreateMaybeMessage< ::private_membership::rlwe::PrivateMembershipRlweOprfRequest >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::PrivateMembershipRlweOprfRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::PrivateMembershipRlweOprfResponse* Arena::CreateMaybeMessage< ::private_membership::rlwe::PrivateMembershipRlweOprfResponse >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::PrivateMembershipRlweOprfResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::PrivateMembershipRlweQueryRequest* Arena::CreateMaybeMessage< ::private_membership::rlwe::PrivateMembershipRlweQueryRequest >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::PrivateMembershipRlweQueryRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::PrivateMembershipRlweQueryResponse* Arena::CreateMaybeMessage< ::private_membership::rlwe::PrivateMembershipRlweQueryResponse >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::PrivateMembershipRlweQueryResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::RlwePlaintextId* Arena::CreateMaybeMessage< ::private_membership::rlwe::RlwePlaintextId >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::RlwePlaintextId >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::HashedBucketsParameters* Arena::CreateMaybeMessage< ::private_membership::rlwe::HashedBucketsParameters >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::HashedBucketsParameters >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::EncryptedBucketsParameters* Arena::CreateMaybeMessage< ::private_membership::rlwe::EncryptedBucketsParameters >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::EncryptedBucketsParameters >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::RlweParameters* Arena::CreateMaybeMessage< ::private_membership::rlwe::RlweParameters >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::RlweParameters >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::Uint128* Arena::CreateMaybeMessage< ::private_membership::rlwe::Uint128 >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::Uint128 >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId* Arena::CreateMaybeMessage< ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::PrivateMembershipRlweQuery_HashedBucketId >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::PrivateMembershipRlweQuery* Arena::CreateMaybeMessage< ::private_membership::rlwe::PrivateMembershipRlweQuery >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::PrivateMembershipRlweQuery >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::PrivateMembershipRlwePirResponse* Arena::CreateMaybeMessage< ::private_membership::rlwe::PrivateMembershipRlwePirResponse >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::PrivateMembershipRlwePirResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::PirRequest* Arena::CreateMaybeMessage< ::private_membership::rlwe::PirRequest >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::PirRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::PirResponse* Arena::CreateMaybeMessage< ::private_membership::rlwe::PirResponse >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::PirResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair* Arena::CreateMaybeMessage< ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::EncryptedBucket_EncryptedIdValuePair >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::EncryptedBucket* Arena::CreateMaybeMessage< ::private_membership::rlwe::EncryptedBucket >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::EncryptedBucket >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry* Arena::CreateMaybeMessage< ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::RlweMembershipResponses_MembershipResponseEntry >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::rlwe::RlweMembershipResponses* Arena::CreateMaybeMessage< ::private_membership::rlwe::RlweMembershipResponses >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::rlwe::RlweMembershipResponses >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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