From a3284b792b0631c1572dcd50c29f346d7b984664 Mon Sep 17 00:00:00 2001 From: irfan sharif Date: Fri, 10 Jul 2020 01:04:11 -0400 Subject: [PATCH] server: introduce join rpc for node id allocation This mostly follows the ideas in #32574, and serves as a crucial building block for #48843. Specifically this PR introduces a new Join RPC that new nodes can use, addressing already initialized nodes, to learn about the cluster ID and its node ID. Previously joining nodes were responsible for allocating their own IDs and used to discover the cluster ID. By moving towards a more understandable flow of how nodes joins the cluster, we can build a few useful primitives on top of this: - we can prevent mismatched version nodes from joining the cluster which (this commit) - we can allocate the first store ID for a given node, which is a nice code simplification (this commit) - we can prevent decommissioned nodes from joining the cluster (future PR) - we can eliminate another usage of gossip where we previously used it to disseminate the cluster ID. In the 21.1 cycle we can defer gossip start until much later in the server start lifecycle (future PR) - we can add the liveness record for a given node as soon as it joins, which would simplify our liveness record handling code that is perennially concerned with missing liveness records (future PR) The tiny bit of complexity in this PR comes from how we're able to migrate into this behavior from the old. To that end we retain the earlier gossip-based cluster ID discovery+node ID allocation for self behavior. Nodes with this patch will attempt to use this join RPC, if implemented on the addressed node, and fall back to using the previous behavior if not. Release justification: low risk, high benefit changes to existing functionality Release note: None --- c-deps/libroach/protos/roachpb/api.pb.cc | 541 ++++++ c-deps/libroach/protos/roachpb/api.pb.h | 436 ++++- pkg/ccl/kvccl/kvtenantccl/connector_test.go | 8 + pkg/cli/init.go | 1 - pkg/cli/start.go | 2 +- pkg/clusterversion/cockroach_versions.go | 1 + pkg/cmd/roachtest/decommission.go | 15 + pkg/kv/kvclient/kvcoord/send_test.go | 6 + pkg/kv/kvclient/kvcoord/transport_test.go | 6 + pkg/kv/kvserver/replica_gossip.go | 2 +- pkg/roachpb/api.pb.go | 1715 ++++++++++++------- pkg/roachpb/api.proto | 23 +- pkg/rpc/context.go | 7 + pkg/rpc/context_test.go | 8 + pkg/server/config.go | 13 +- pkg/server/config_test.go | 7 +- pkg/server/init.go | 560 ++++-- pkg/server/node.go | 77 +- pkg/server/server.go | 110 +- pkg/server/serverpb/init.pb.go | 18 +- pkg/server/serverpb/init.proto | 15 +- pkg/server/status.go | 2 +- 22 files changed, 2743 insertions(+), 830 deletions(-) diff --git a/c-deps/libroach/protos/roachpb/api.pb.cc b/c-deps/libroach/protos/roachpb/api.pb.cc index d0de91fa9459..6b2aa374ec1d 100644 --- a/c-deps/libroach/protos/roachpb/api.pb.cc +++ b/c-deps/libroach/protos/roachpb/api.pb.cc @@ -150,6 +150,7 @@ extern PROTOBUF_INTERNAL_EXPORT_protobuf_roachpb_2ferrors_2eproto ::google::prot namespace protobuf_roachpb_2fmetadata_2eproto { extern PROTOBUF_INTERNAL_EXPORT_protobuf_roachpb_2fmetadata_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_ReplicaDescriptor; extern PROTOBUF_INTERNAL_EXPORT_protobuf_roachpb_2fmetadata_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_ReplicationTarget; +extern PROTOBUF_INTERNAL_EXPORT_protobuf_roachpb_2fmetadata_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_Version; extern PROTOBUF_INTERNAL_EXPORT_protobuf_roachpb_2fmetadata_2eproto ::google::protobuf::internal::SCCInfo<2> scc_info_RangeDescriptor; } // namespace protobuf_roachpb_2fmetadata_2eproto namespace protobuf_storage_2fenginepb_2fmvcc3_2eproto { @@ -875,6 +876,16 @@ class GossipSubscriptionEventDefaultTypeInternal { ::google::protobuf::internal::ExplicitlyConstructed _instance; } _GossipSubscriptionEvent_default_instance_; +class JoinNodeRequestDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _JoinNodeRequest_default_instance_; +class JoinNodeResponseDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _JoinNodeResponse_default_instance_; } // namespace roachpb } // namespace cockroach namespace protobuf_roachpb_2fapi_2eproto { @@ -2900,6 +2911,36 @@ ::google::protobuf::internal::SCCInfo<2> scc_info_GossipSubscriptionEvent = &protobuf_roachpb_2fdata_2eproto::scc_info_Value.base, &protobuf_roachpb_2ferrors_2eproto::scc_info_AmbiguousResultError.base,}}; +static void InitDefaultsJoinNodeRequest() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::cockroach::roachpb::_JoinNodeRequest_default_instance_; + new (ptr) ::cockroach::roachpb::JoinNodeRequest(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::cockroach::roachpb::JoinNodeRequest::InitAsDefaultInstance(); +} + +::google::protobuf::internal::SCCInfo<1> scc_info_JoinNodeRequest = + {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsJoinNodeRequest}, { + &protobuf_roachpb_2fmetadata_2eproto::scc_info_Version.base,}}; + +static void InitDefaultsJoinNodeResponse() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::cockroach::roachpb::_JoinNodeResponse_default_instance_; + new (ptr) ::cockroach::roachpb::JoinNodeResponse(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::cockroach::roachpb::JoinNodeResponse::InitAsDefaultInstance(); +} + +::google::protobuf::internal::SCCInfo<1> scc_info_JoinNodeResponse = + {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsJoinNodeResponse}, { + &protobuf_roachpb_2fmetadata_2eproto::scc_info_Version.base,}}; + void InitDefaults() { ::google::protobuf::internal::InitSCC(&scc_info_RequestHeader.base); ::google::protobuf::internal::InitSCC(&scc_info_ResponseHeader.base); @@ -3025,6 +3066,8 @@ void InitDefaults() { ::google::protobuf::internal::InitSCC(&scc_info_RangeFeedEvent.base); ::google::protobuf::internal::InitSCC(&scc_info_GossipSubscriptionRequest.base); ::google::protobuf::internal::InitSCC(&scc_info_GossipSubscriptionEvent.base); + ::google::protobuf::internal::InitSCC(&scc_info_JoinNodeRequest.base); + ::google::protobuf::internal::InitSCC(&scc_info_JoinNodeResponse.base); } } // namespace protobuf_roachpb_2fapi_2eproto @@ -39743,6 +39786,498 @@ ::std::string GossipSubscriptionEvent::GetTypeName() const { } +// =================================================================== + +void JoinNodeRequest::InitAsDefaultInstance() { + ::cockroach::roachpb::_JoinNodeRequest_default_instance_._instance.get_mutable()->binary_version_ = const_cast< ::cockroach::roachpb::Version*>( + ::cockroach::roachpb::Version::internal_default_instance()); +} +void JoinNodeRequest::clear_binary_version() { + if (GetArenaNoVirtual() == NULL && binary_version_ != NULL) { + delete binary_version_; + } + binary_version_ = NULL; +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int JoinNodeRequest::kBinaryVersionFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +JoinNodeRequest::JoinNodeRequest() + : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) { + ::google::protobuf::internal::InitSCC( + &protobuf_roachpb_2fapi_2eproto::scc_info_JoinNodeRequest.base); + SharedCtor(); + // @@protoc_insertion_point(constructor:cockroach.roachpb.JoinNodeRequest) +} +JoinNodeRequest::JoinNodeRequest(const JoinNodeRequest& from) + : ::google::protobuf::MessageLite(), + _internal_metadata_(NULL) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_binary_version()) { + binary_version_ = new ::cockroach::roachpb::Version(*from.binary_version_); + } else { + binary_version_ = NULL; + } + // @@protoc_insertion_point(copy_constructor:cockroach.roachpb.JoinNodeRequest) +} + +void JoinNodeRequest::SharedCtor() { + binary_version_ = NULL; +} + +JoinNodeRequest::~JoinNodeRequest() { + // @@protoc_insertion_point(destructor:cockroach.roachpb.JoinNodeRequest) + SharedDtor(); +} + +void JoinNodeRequest::SharedDtor() { + if (this != internal_default_instance()) delete binary_version_; +} + +void JoinNodeRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const JoinNodeRequest& JoinNodeRequest::default_instance() { + ::google::protobuf::internal::InitSCC(&protobuf_roachpb_2fapi_2eproto::scc_info_JoinNodeRequest.base); + return *internal_default_instance(); +} + + +void JoinNodeRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:cockroach.roachpb.JoinNodeRequest) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaNoVirtual() == NULL && binary_version_ != NULL) { + delete binary_version_; + } + binary_version_ = NULL; + _internal_metadata_.Clear(); +} + +bool JoinNodeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::internal::LiteUnknownFieldSetter unknown_fields_setter( + &_internal_metadata_); + ::google::protobuf::io::StringOutputStream unknown_fields_output( + unknown_fields_setter.buffer()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_output, false); + // @@protoc_insertion_point(parse_start:cockroach.roachpb.JoinNodeRequest) + for (;;) { + ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .cockroach.roachpb.Version binary_version = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_binary_version())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:cockroach.roachpb.JoinNodeRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:cockroach.roachpb.JoinNodeRequest) + return false; +#undef DO_ +} + +void JoinNodeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:cockroach.roachpb.JoinNodeRequest) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .cockroach.roachpb.Version binary_version = 1; + if (this->has_binary_version()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->_internal_binary_version(), output); + } + + output->WriteRaw((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).data(), + static_cast((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size())); + // @@protoc_insertion_point(serialize_end:cockroach.roachpb.JoinNodeRequest) +} + +size_t JoinNodeRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:cockroach.roachpb.JoinNodeRequest) + size_t total_size = 0; + + total_size += (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size(); + + // .cockroach.roachpb.Version binary_version = 1; + if (this->has_binary_version()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *binary_version_); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void JoinNodeRequest::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void JoinNodeRequest::MergeFrom(const JoinNodeRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:cockroach.roachpb.JoinNodeRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_binary_version()) { + mutable_binary_version()->::cockroach::roachpb::Version::MergeFrom(from.binary_version()); + } +} + +void JoinNodeRequest::CopyFrom(const JoinNodeRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cockroach.roachpb.JoinNodeRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool JoinNodeRequest::IsInitialized() const { + return true; +} + +void JoinNodeRequest::Swap(JoinNodeRequest* other) { + if (other == this) return; + InternalSwap(other); +} +void JoinNodeRequest::InternalSwap(JoinNodeRequest* other) { + using std::swap; + swap(binary_version_, other->binary_version_); + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::std::string JoinNodeRequest::GetTypeName() const { + return "cockroach.roachpb.JoinNodeRequest"; +} + + +// =================================================================== + +void JoinNodeResponse::InitAsDefaultInstance() { + ::cockroach::roachpb::_JoinNodeResponse_default_instance_._instance.get_mutable()->active_version_ = const_cast< ::cockroach::roachpb::Version*>( + ::cockroach::roachpb::Version::internal_default_instance()); +} +void JoinNodeResponse::clear_active_version() { + if (GetArenaNoVirtual() == NULL && active_version_ != NULL) { + delete active_version_; + } + active_version_ = NULL; +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int JoinNodeResponse::kClusterIdFieldNumber; +const int JoinNodeResponse::kNodeIdFieldNumber; +const int JoinNodeResponse::kStoreIdFieldNumber; +const int JoinNodeResponse::kActiveVersionFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +JoinNodeResponse::JoinNodeResponse() + : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) { + ::google::protobuf::internal::InitSCC( + &protobuf_roachpb_2fapi_2eproto::scc_info_JoinNodeResponse.base); + SharedCtor(); + // @@protoc_insertion_point(constructor:cockroach.roachpb.JoinNodeResponse) +} +JoinNodeResponse::JoinNodeResponse(const JoinNodeResponse& from) + : ::google::protobuf::MessageLite(), + _internal_metadata_(NULL) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + cluster_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.cluster_id().size() > 0) { + cluster_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.cluster_id_); + } + if (from.has_active_version()) { + active_version_ = new ::cockroach::roachpb::Version(*from.active_version_); + } else { + active_version_ = NULL; + } + ::memcpy(&node_id_, &from.node_id_, + static_cast(reinterpret_cast(&store_id_) - + reinterpret_cast(&node_id_)) + sizeof(store_id_)); + // @@protoc_insertion_point(copy_constructor:cockroach.roachpb.JoinNodeResponse) +} + +void JoinNodeResponse::SharedCtor() { + cluster_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&active_version_, 0, static_cast( + reinterpret_cast(&store_id_) - + reinterpret_cast(&active_version_)) + sizeof(store_id_)); +} + +JoinNodeResponse::~JoinNodeResponse() { + // @@protoc_insertion_point(destructor:cockroach.roachpb.JoinNodeResponse) + SharedDtor(); +} + +void JoinNodeResponse::SharedDtor() { + cluster_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete active_version_; +} + +void JoinNodeResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const JoinNodeResponse& JoinNodeResponse::default_instance() { + ::google::protobuf::internal::InitSCC(&protobuf_roachpb_2fapi_2eproto::scc_info_JoinNodeResponse.base); + return *internal_default_instance(); +} + + +void JoinNodeResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:cockroach.roachpb.JoinNodeResponse) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cluster_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == NULL && active_version_ != NULL) { + delete active_version_; + } + active_version_ = NULL; + ::memset(&node_id_, 0, static_cast( + reinterpret_cast(&store_id_) - + reinterpret_cast(&node_id_)) + sizeof(store_id_)); + _internal_metadata_.Clear(); +} + +bool JoinNodeResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::internal::LiteUnknownFieldSetter unknown_fields_setter( + &_internal_metadata_); + ::google::protobuf::io::StringOutputStream unknown_fields_output( + unknown_fields_setter.buffer()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_output, false); + // @@protoc_insertion_point(parse_start:cockroach.roachpb.JoinNodeResponse) + for (;;) { + ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_cluster_id())); + } else { + goto handle_unusual; + } + break; + } + + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &node_id_))); + } else { + goto handle_unusual; + } + break; + } + + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &store_id_))); + } else { + goto handle_unusual; + } + break; + } + + // .cockroach.roachpb.Version active_version = 4; + case 4: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_active_version())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:cockroach.roachpb.JoinNodeResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:cockroach.roachpb.JoinNodeResponse) + return false; +#undef DO_ +} + +void JoinNodeResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:cockroach.roachpb.JoinNodeResponse) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (this->cluster_id().size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->cluster_id(), output); + } + + if (this->node_id() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->node_id(), output); + } + + if (this->store_id() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->store_id(), output); + } + + // .cockroach.roachpb.Version active_version = 4; + if (this->has_active_version()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 4, this->_internal_active_version(), output); + } + + output->WriteRaw((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).data(), + static_cast((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size())); + // @@protoc_insertion_point(serialize_end:cockroach.roachpb.JoinNodeResponse) +} + +size_t JoinNodeResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:cockroach.roachpb.JoinNodeResponse) + size_t total_size = 0; + + total_size += (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size(); + + if (this->cluster_id().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->cluster_id()); + } + + // .cockroach.roachpb.Version active_version = 4; + if (this->has_active_version()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *active_version_); + } + + if (this->node_id() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->node_id()); + } + + if (this->store_id() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->store_id()); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void JoinNodeResponse::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void JoinNodeResponse::MergeFrom(const JoinNodeResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:cockroach.roachpb.JoinNodeResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.cluster_id().size() > 0) { + + cluster_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.cluster_id_); + } + if (from.has_active_version()) { + mutable_active_version()->::cockroach::roachpb::Version::MergeFrom(from.active_version()); + } + if (from.node_id() != 0) { + set_node_id(from.node_id()); + } + if (from.store_id() != 0) { + set_store_id(from.store_id()); + } +} + +void JoinNodeResponse::CopyFrom(const JoinNodeResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cockroach.roachpb.JoinNodeResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool JoinNodeResponse::IsInitialized() const { + return true; +} + +void JoinNodeResponse::Swap(JoinNodeResponse* other) { + if (other == this) return; + InternalSwap(other); +} +void JoinNodeResponse::InternalSwap(JoinNodeResponse* other) { + using std::swap; + cluster_id_.Swap(&other->cluster_id_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(active_version_, other->active_version_); + swap(node_id_, other->node_id_); + swap(store_id_, other->store_id_); + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::std::string JoinNodeResponse::GetTypeName() const { + return "cockroach.roachpb.JoinNodeResponse"; +} + + // @@protoc_insertion_point(namespace_scope) } // namespace roachpb } // namespace cockroach @@ -40120,6 +40655,12 @@ template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::GossipSubscr template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::GossipSubscriptionEvent* Arena::CreateMaybeMessage< ::cockroach::roachpb::GossipSubscriptionEvent >(Arena* arena) { return Arena::CreateInternal< ::cockroach::roachpb::GossipSubscriptionEvent >(arena); } +template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::JoinNodeRequest* Arena::CreateMaybeMessage< ::cockroach::roachpb::JoinNodeRequest >(Arena* arena) { + return Arena::CreateInternal< ::cockroach::roachpb::JoinNodeRequest >(arena); +} +template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::JoinNodeResponse* Arena::CreateMaybeMessage< ::cockroach::roachpb::JoinNodeResponse >(Arena* arena) { + return Arena::CreateInternal< ::cockroach::roachpb::JoinNodeResponse >(arena); +} } // namespace protobuf } // namespace google diff --git a/c-deps/libroach/protos/roachpb/api.pb.h b/c-deps/libroach/protos/roachpb/api.pb.h index 08a6da200ba5..e3ed20357c72 100644 --- a/c-deps/libroach/protos/roachpb/api.pb.h +++ b/c-deps/libroach/protos/roachpb/api.pb.h @@ -49,7 +49,7 @@ namespace protobuf_roachpb_2fapi_2eproto { struct TableStruct { static const ::google::protobuf::internal::ParseTableField entries[]; static const ::google::protobuf::internal::AuxillaryParseTableField aux[]; - static const ::google::protobuf::internal::ParseTable schema[124]; + static const ::google::protobuf::internal::ParseTable schema[126]; static const ::google::protobuf::internal::FieldMetadata field_metadata[]; static const ::google::protobuf::internal::SerializationTable serialization_table[]; static const ::google::protobuf::uint32 offsets[]; @@ -270,6 +270,12 @@ extern InitPutRequestDefaultTypeInternal _InitPutRequest_default_instance_; class InitPutResponse; class InitPutResponseDefaultTypeInternal; extern InitPutResponseDefaultTypeInternal _InitPutResponse_default_instance_; +class JoinNodeRequest; +class JoinNodeRequestDefaultTypeInternal; +extern JoinNodeRequestDefaultTypeInternal _JoinNodeRequest_default_instance_; +class JoinNodeResponse; +class JoinNodeResponseDefaultTypeInternal; +extern JoinNodeResponseDefaultTypeInternal _JoinNodeResponse_default_instance_; class LeaseInfoRequest; class LeaseInfoRequestDefaultTypeInternal; extern LeaseInfoRequestDefaultTypeInternal _LeaseInfoRequest_default_instance_; @@ -504,6 +510,8 @@ template<> ::cockroach::roachpb::IncrementRequest* Arena::CreateMaybeMessage<::c template<> ::cockroach::roachpb::IncrementResponse* Arena::CreateMaybeMessage<::cockroach::roachpb::IncrementResponse>(Arena*); template<> ::cockroach::roachpb::InitPutRequest* Arena::CreateMaybeMessage<::cockroach::roachpb::InitPutRequest>(Arena*); template<> ::cockroach::roachpb::InitPutResponse* Arena::CreateMaybeMessage<::cockroach::roachpb::InitPutResponse>(Arena*); +template<> ::cockroach::roachpb::JoinNodeRequest* Arena::CreateMaybeMessage<::cockroach::roachpb::JoinNodeRequest>(Arena*); +template<> ::cockroach::roachpb::JoinNodeResponse* Arena::CreateMaybeMessage<::cockroach::roachpb::JoinNodeResponse>(Arena*); template<> ::cockroach::roachpb::LeaseInfoRequest* Arena::CreateMaybeMessage<::cockroach::roachpb::LeaseInfoRequest>(Arena*); template<> ::cockroach::roachpb::LeaseInfoResponse* Arena::CreateMaybeMessage<::cockroach::roachpb::LeaseInfoResponse>(Arena*); template<> ::cockroach::roachpb::MergeRequest* Arena::CreateMaybeMessage<::cockroach::roachpb::MergeRequest>(Arena*); @@ -17584,6 +17592,246 @@ class GossipSubscriptionEvent : public ::google::protobuf::MessageLite /* @@prot mutable ::google::protobuf::internal::CachedSize _cached_size_; friend struct ::protobuf_roachpb_2fapi_2eproto::TableStruct; }; +// ------------------------------------------------------------------- + +class JoinNodeRequest : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.JoinNodeRequest) */ { + public: + JoinNodeRequest(); + virtual ~JoinNodeRequest(); + + JoinNodeRequest(const JoinNodeRequest& from); + + inline JoinNodeRequest& operator=(const JoinNodeRequest& from) { + CopyFrom(from); + return *this; + } + #if LANG_CXX11 + JoinNodeRequest(JoinNodeRequest&& from) noexcept + : JoinNodeRequest() { + *this = ::std::move(from); + } + + inline JoinNodeRequest& operator=(JoinNodeRequest&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + #endif + static const JoinNodeRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const JoinNodeRequest* internal_default_instance() { + return reinterpret_cast( + &_JoinNodeRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 124; + + void Swap(JoinNodeRequest* other); + friend void swap(JoinNodeRequest& a, JoinNodeRequest& b) { + a.Swap(&b); + } + + // implements Message ---------------------------------------------- + + inline JoinNodeRequest* New() const final { + return CreateMaybeMessage(NULL); + } + + JoinNodeRequest* New(::google::protobuf::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from) + final; + void CopyFrom(const JoinNodeRequest& from); + void MergeFrom(const JoinNodeRequest& from); + void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) final; + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(JoinNodeRequest* other); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return NULL; + } + inline void* MaybeArenaPtr() const { + return NULL; + } + public: + + ::std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // .cockroach.roachpb.Version binary_version = 1; + bool has_binary_version() const; + void clear_binary_version(); + static const int kBinaryVersionFieldNumber = 1; + private: + const ::cockroach::roachpb::Version& _internal_binary_version() const; + public: + const ::cockroach::roachpb::Version& binary_version() const; + ::cockroach::roachpb::Version* release_binary_version(); + ::cockroach::roachpb::Version* mutable_binary_version(); + void set_allocated_binary_version(::cockroach::roachpb::Version* binary_version); + + // @@protoc_insertion_point(class_scope:cockroach.roachpb.JoinNodeRequest) + private: + + ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::cockroach::roachpb::Version* binary_version_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + friend struct ::protobuf_roachpb_2fapi_2eproto::TableStruct; +}; +// ------------------------------------------------------------------- + +class JoinNodeResponse : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.JoinNodeResponse) */ { + public: + JoinNodeResponse(); + virtual ~JoinNodeResponse(); + + JoinNodeResponse(const JoinNodeResponse& from); + + inline JoinNodeResponse& operator=(const JoinNodeResponse& from) { + CopyFrom(from); + return *this; + } + #if LANG_CXX11 + JoinNodeResponse(JoinNodeResponse&& from) noexcept + : JoinNodeResponse() { + *this = ::std::move(from); + } + + inline JoinNodeResponse& operator=(JoinNodeResponse&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + #endif + static const JoinNodeResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const JoinNodeResponse* internal_default_instance() { + return reinterpret_cast( + &_JoinNodeResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 125; + + void Swap(JoinNodeResponse* other); + friend void swap(JoinNodeResponse& a, JoinNodeResponse& b) { + a.Swap(&b); + } + + // implements Message ---------------------------------------------- + + inline JoinNodeResponse* New() const final { + return CreateMaybeMessage(NULL); + } + + JoinNodeResponse* New(::google::protobuf::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from) + final; + void CopyFrom(const JoinNodeResponse& from); + void MergeFrom(const JoinNodeResponse& from); + void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) final; + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(JoinNodeResponse* other); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return NULL; + } + inline void* MaybeArenaPtr() const { + return NULL; + } + public: + + ::std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + void clear_cluster_id(); + static const int kClusterIdFieldNumber = 1; + const ::std::string& cluster_id() const; + void set_cluster_id(const ::std::string& value); + #if LANG_CXX11 + void set_cluster_id(::std::string&& value); + #endif + void set_cluster_id(const char* value); + void set_cluster_id(const void* value, size_t size); + ::std::string* mutable_cluster_id(); + ::std::string* release_cluster_id(); + void set_allocated_cluster_id(::std::string* cluster_id); + + // .cockroach.roachpb.Version active_version = 4; + bool has_active_version() const; + void clear_active_version(); + static const int kActiveVersionFieldNumber = 4; + private: + const ::cockroach::roachpb::Version& _internal_active_version() const; + public: + const ::cockroach::roachpb::Version& active_version() const; + ::cockroach::roachpb::Version* release_active_version(); + ::cockroach::roachpb::Version* mutable_active_version(); + void set_allocated_active_version(::cockroach::roachpb::Version* active_version); + + void clear_node_id(); + static const int kNodeIdFieldNumber = 2; + ::google::protobuf::int32 node_id() const; + void set_node_id(::google::protobuf::int32 value); + + void clear_store_id(); + static const int kStoreIdFieldNumber = 3; + ::google::protobuf::int32 store_id() const; + void set_store_id(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:cockroach.roachpb.JoinNodeResponse) + private: + + ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::google::protobuf::internal::ArenaStringPtr cluster_id_; + ::cockroach::roachpb::Version* active_version_; + ::google::protobuf::int32 node_id_; + ::google::protobuf::int32 store_id_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + friend struct ::protobuf_roachpb_2fapi_2eproto::TableStruct; +}; // =================================================================== @@ -36134,6 +36382,188 @@ inline void GossipSubscriptionEvent::set_allocated_error(::cockroach::roachpb::E // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.GossipSubscriptionEvent.error) } +// ------------------------------------------------------------------- + +// JoinNodeRequest + +// .cockroach.roachpb.Version binary_version = 1; +inline bool JoinNodeRequest::has_binary_version() const { + return this != internal_default_instance() && binary_version_ != NULL; +} +inline const ::cockroach::roachpb::Version& JoinNodeRequest::_internal_binary_version() const { + return *binary_version_; +} +inline const ::cockroach::roachpb::Version& JoinNodeRequest::binary_version() const { + const ::cockroach::roachpb::Version* p = binary_version_; + // @@protoc_insertion_point(field_get:cockroach.roachpb.JoinNodeRequest.binary_version) + return p != NULL ? *p : *reinterpret_cast( + &::cockroach::roachpb::_Version_default_instance_); +} +inline ::cockroach::roachpb::Version* JoinNodeRequest::release_binary_version() { + // @@protoc_insertion_point(field_release:cockroach.roachpb.JoinNodeRequest.binary_version) + + ::cockroach::roachpb::Version* temp = binary_version_; + binary_version_ = NULL; + return temp; +} +inline ::cockroach::roachpb::Version* JoinNodeRequest::mutable_binary_version() { + + if (binary_version_ == NULL) { + auto* p = CreateMaybeMessage<::cockroach::roachpb::Version>(GetArenaNoVirtual()); + binary_version_ = p; + } + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.JoinNodeRequest.binary_version) + return binary_version_; +} +inline void JoinNodeRequest::set_allocated_binary_version(::cockroach::roachpb::Version* binary_version) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete reinterpret_cast< ::google::protobuf::MessageLite*>(binary_version_); + } + if (binary_version) { + ::google::protobuf::Arena* submessage_arena = NULL; + if (message_arena != submessage_arena) { + binary_version = ::google::protobuf::internal::GetOwnedMessage( + message_arena, binary_version, submessage_arena); + } + + } else { + + } + binary_version_ = binary_version; + // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.JoinNodeRequest.binary_version) +} + +// ------------------------------------------------------------------- + +// JoinNodeResponse + +inline void JoinNodeResponse::clear_cluster_id() { + cluster_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline const ::std::string& JoinNodeResponse::cluster_id() const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.JoinNodeResponse.cluster_id) + return cluster_id_.GetNoArena(); +} +inline void JoinNodeResponse::set_cluster_id(const ::std::string& value) { + + cluster_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:cockroach.roachpb.JoinNodeResponse.cluster_id) +} +#if LANG_CXX11 +inline void JoinNodeResponse::set_cluster_id(::std::string&& value) { + + cluster_id_.SetNoArena( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.JoinNodeResponse.cluster_id) +} +#endif +inline void JoinNodeResponse::set_cluster_id(const char* value) { + GOOGLE_DCHECK(value != NULL); + + cluster_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:cockroach.roachpb.JoinNodeResponse.cluster_id) +} +inline void JoinNodeResponse::set_cluster_id(const void* value, size_t size) { + + cluster_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.JoinNodeResponse.cluster_id) +} +inline ::std::string* JoinNodeResponse::mutable_cluster_id() { + + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.JoinNodeResponse.cluster_id) + return cluster_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* JoinNodeResponse::release_cluster_id() { + // @@protoc_insertion_point(field_release:cockroach.roachpb.JoinNodeResponse.cluster_id) + + return cluster_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void JoinNodeResponse::set_allocated_cluster_id(::std::string* cluster_id) { + if (cluster_id != NULL) { + + } else { + + } + cluster_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), cluster_id); + // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.JoinNodeResponse.cluster_id) +} + +inline void JoinNodeResponse::clear_node_id() { + node_id_ = 0; +} +inline ::google::protobuf::int32 JoinNodeResponse::node_id() const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.JoinNodeResponse.node_id) + return node_id_; +} +inline void JoinNodeResponse::set_node_id(::google::protobuf::int32 value) { + + node_id_ = value; + // @@protoc_insertion_point(field_set:cockroach.roachpb.JoinNodeResponse.node_id) +} + +inline void JoinNodeResponse::clear_store_id() { + store_id_ = 0; +} +inline ::google::protobuf::int32 JoinNodeResponse::store_id() const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.JoinNodeResponse.store_id) + return store_id_; +} +inline void JoinNodeResponse::set_store_id(::google::protobuf::int32 value) { + + store_id_ = value; + // @@protoc_insertion_point(field_set:cockroach.roachpb.JoinNodeResponse.store_id) +} + +// .cockroach.roachpb.Version active_version = 4; +inline bool JoinNodeResponse::has_active_version() const { + return this != internal_default_instance() && active_version_ != NULL; +} +inline const ::cockroach::roachpb::Version& JoinNodeResponse::_internal_active_version() const { + return *active_version_; +} +inline const ::cockroach::roachpb::Version& JoinNodeResponse::active_version() const { + const ::cockroach::roachpb::Version* p = active_version_; + // @@protoc_insertion_point(field_get:cockroach.roachpb.JoinNodeResponse.active_version) + return p != NULL ? *p : *reinterpret_cast( + &::cockroach::roachpb::_Version_default_instance_); +} +inline ::cockroach::roachpb::Version* JoinNodeResponse::release_active_version() { + // @@protoc_insertion_point(field_release:cockroach.roachpb.JoinNodeResponse.active_version) + + ::cockroach::roachpb::Version* temp = active_version_; + active_version_ = NULL; + return temp; +} +inline ::cockroach::roachpb::Version* JoinNodeResponse::mutable_active_version() { + + if (active_version_ == NULL) { + auto* p = CreateMaybeMessage<::cockroach::roachpb::Version>(GetArenaNoVirtual()); + active_version_ = p; + } + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.JoinNodeResponse.active_version) + return active_version_; +} +inline void JoinNodeResponse::set_allocated_active_version(::cockroach::roachpb::Version* active_version) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete reinterpret_cast< ::google::protobuf::MessageLite*>(active_version_); + } + if (active_version) { + ::google::protobuf::Arena* submessage_arena = NULL; + if (message_arena != submessage_arena) { + active_version = ::google::protobuf::internal::GetOwnedMessage( + message_arena, active_version, submessage_arena); + } + + } else { + + } + active_version_ = active_version; + // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.JoinNodeResponse.active_version) +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -36383,6 +36813,10 @@ inline void GossipSubscriptionEvent::set_allocated_error(::cockroach::roachpb::E // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/pkg/ccl/kvccl/kvtenantccl/connector_test.go b/pkg/ccl/kvccl/kvtenantccl/connector_test.go index 075b6ba7c8e6..aec146c2459f 100644 --- a/pkg/ccl/kvccl/kvtenantccl/connector_test.go +++ b/pkg/ccl/kvccl/kvtenantccl/connector_test.go @@ -39,6 +39,8 @@ var rpcRetryOpts = retry.Options{ MaxBackoff: 4 * time.Microsecond, } +var _ roachpb.InternalServer = &mockServer{} + type mockServer struct { rangeLookupFn func(context.Context, *roachpb.RangeLookupRequest) (*roachpb.RangeLookupResponse, error) gossipSubFn func(*roachpb.GossipSubscriptionRequest, roachpb.Internal_GossipSubscriptionServer) error @@ -64,6 +66,12 @@ func (*mockServer) RangeFeed(*roachpb.RangeFeedRequest, roachpb.Internal_RangeFe panic("unimplemented") } +func (m *mockServer) Join( + context.Context, *roachpb.JoinNodeRequest, +) (*roachpb.JoinNodeResponse, error) { + panic("unimplemented") +} + func gossipEventForNodeDesc(desc *roachpb.NodeDescriptor) *roachpb.GossipSubscriptionEvent { val, err := protoutil.Marshal(desc) if err != nil { diff --git a/pkg/cli/init.go b/pkg/cli/init.go index d8e34c5626c2..3cc744e8c7ab 100644 --- a/pkg/cli/init.go +++ b/pkg/cli/init.go @@ -51,7 +51,6 @@ func runInit(cmd *cobra.Command, args []string) error { // Actually perform cluster initialization. c := serverpb.NewInitClient(conn) - if _, err = c.Bootstrap(ctx, &serverpb.BootstrapRequest{}); err != nil { return err } diff --git a/pkg/cli/start.go b/pkg/cli/start.go index aebfc42b333d..b0a513b9fd6d 100644 --- a/pkg/cli/start.go +++ b/pkg/cli/start.go @@ -455,7 +455,7 @@ func runStart(cmd *cobra.Command, args []string, disableReplication bool) error if waitForInit { log.Shout(ctx, log.Severity_INFO, - "initial startup completed.\n"+ + "initial startup completed\n"+ "Node will now attempt to join a running cluster, or wait for `cockroach init`.\n"+ "Client connections will be accepted after this completes successfully.\n"+ "Check the log file(s) for progress. ") diff --git a/pkg/clusterversion/cockroach_versions.go b/pkg/clusterversion/cockroach_versions.go index 6e48d290c8bf..28c1270dcee1 100644 --- a/pkg/clusterversion/cockroach_versions.go +++ b/pkg/clusterversion/cockroach_versions.go @@ -611,6 +611,7 @@ var ( // this binary. If this binary is started using a store marked with an older // version than binaryMinSupportedVersion, then the binary will exit with // an error. + // // We support everything after 19.1, including pre-release 19.2 versions. // This is generally beneficial, but in particular it allows the // version-upgrade roachtest to use a pre-release 19.2 binary before upgrading diff --git a/pkg/cmd/roachtest/decommission.go b/pkg/cmd/roachtest/decommission.go index 193b4ce5b25e..dd2485836e80 100644 --- a/pkg/cmd/roachtest/decommission.go +++ b/pkg/cmd/roachtest/decommission.go @@ -309,6 +309,21 @@ func runDecommissionRandomized(ctx context.Context, t *test, c *cluster) { Multiplier: 2, } + // This is a pretty gross hack to let the bootstrap info (cluster ID, + // liveness records) disseminate through the cluster. Since it's no longer + // happening through gossip, it takes a bit longer to happen. We should do + // two things to improve our story here: + // + // - We should opportunistically write to the liveness table when adding a + // node through the Join RPC. This would also simplify the handling of + // empty liveness records (they would no longer exist). + // - We should add roachtest helpers that wait until each node has received + // cluster ID information, and use it in all the tests that need it (which + // may very well be all the tests). + // + // TODO(irfansharif): Do the above. + time.Sleep(30 * time.Second) + // Partially decommission then recommission a random node, from another // random node. Run a couple of status checks while doing so. { diff --git a/pkg/kv/kvclient/kvcoord/send_test.go b/pkg/kv/kvclient/kvcoord/send_test.go index dfe4c86484aa..8321999c29ab 100644 --- a/pkg/kv/kvclient/kvcoord/send_test.go +++ b/pkg/kv/kvclient/kvcoord/send_test.go @@ -34,6 +34,8 @@ import ( "github.com/stretchr/testify/require" ) +var _ roachpb.InternalServer = Node(0) + type Node time.Duration func (n Node) Batch( @@ -61,6 +63,10 @@ func (n Node) GossipSubscription( panic("unimplemented") } +func (n Node) Join(context.Context, *roachpb.JoinNodeRequest) (*roachpb.JoinNodeResponse, error) { + panic("unimplemented") +} + // TestSendToOneClient verifies that Send correctly sends a request // to one server using the heartbeat RPC. func TestSendToOneClient(t *testing.T) { diff --git a/pkg/kv/kvclient/kvcoord/transport_test.go b/pkg/kv/kvclient/kvcoord/transport_test.go index 615054ae16a8..e10c1654d4c4 100644 --- a/pkg/kv/kvclient/kvcoord/transport_test.go +++ b/pkg/kv/kvclient/kvcoord/transport_test.go @@ -179,3 +179,9 @@ func (m *mockInternalClient) GossipSubscription( ) (roachpb.Internal_GossipSubscriptionClient, error) { return nil, fmt.Errorf("unsupported GossipSubscripion call") } + +func (m *mockInternalClient) Join( + context.Context, *roachpb.JoinNodeRequest, ...grpc.CallOption, +) (*roachpb.JoinNodeResponse, error) { + return nil, fmt.Errorf("unsupported Join call") +} diff --git a/pkg/kv/kvserver/replica_gossip.go b/pkg/kv/kvserver/replica_gossip.go index c594b1080107..9ef8f487edec 100644 --- a/pkg/kv/kvserver/replica_gossip.go +++ b/pkg/kv/kvserver/replica_gossip.go @@ -287,7 +287,7 @@ func (r *Replica) maybeGossipFirstRange(ctx context.Context) *roachpb.Error { // Gossip the cluster ID from all replicas of the first range; there // is no expiration on the cluster ID. if log.V(1) { - log.Infof(ctx, "gossiping cluster id %q from store %d, r%d", r.store.ClusterID(), + log.Infof(ctx, "gossiping cluster ID %q from store %d, r%d", r.store.ClusterID(), r.store.StoreID(), r.RangeID) } if err := r.store.Gossip().AddClusterID(r.store.ClusterID()); err != nil { diff --git a/pkg/roachpb/api.pb.go b/pkg/roachpb/api.pb.go index 8f5ce0a8b01a..77e35a53e20c 100644 --- a/pkg/roachpb/api.pb.go +++ b/pkg/roachpb/api.pb.go @@ -72,7 +72,7 @@ func (x ReadConsistencyType) String() string { return proto.EnumName(ReadConsistencyType_name, int32(x)) } func (ReadConsistencyType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{0} + return fileDescriptor_api_fc904b6f390e813c, []int{0} } // ScanFormat is an enumeration of the available response formats for MVCCScan @@ -100,7 +100,7 @@ func (x ScanFormat) String() string { return proto.EnumName(ScanFormat_name, int32(x)) } func (ScanFormat) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{1} + return fileDescriptor_api_fc904b6f390e813c, []int{1} } type ChecksumMode int32 @@ -147,7 +147,7 @@ func (x ChecksumMode) String() string { return proto.EnumName(ChecksumMode_name, int32(x)) } func (ChecksumMode) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{2} + return fileDescriptor_api_fc904b6f390e813c, []int{2} } // PushTxnType determines what action to take when pushing a transaction. @@ -178,7 +178,7 @@ func (x PushTxnType) String() string { return proto.EnumName(PushTxnType_name, int32(x)) } func (PushTxnType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{3} + return fileDescriptor_api_fc904b6f390e813c, []int{3} } type ExternalStorageProvider int32 @@ -219,7 +219,7 @@ func (x ExternalStorageProvider) String() string { return proto.EnumName(ExternalStorageProvider_name, int32(x)) } func (ExternalStorageProvider) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{4} + return fileDescriptor_api_fc904b6f390e813c, []int{4} } type MVCCFilter int32 @@ -242,7 +242,7 @@ func (x MVCCFilter) String() string { return proto.EnumName(MVCCFilter_name, int32(x)) } func (MVCCFilter) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{5} + return fileDescriptor_api_fc904b6f390e813c, []int{5} } type ResponseHeader_ResumeReason int32 @@ -268,7 +268,7 @@ func (x ResponseHeader_ResumeReason) String() string { return proto.EnumName(ResponseHeader_ResumeReason_name, int32(x)) } func (ResponseHeader_ResumeReason) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{1, 0} + return fileDescriptor_api_fc904b6f390e813c, []int{1, 0} } type CheckConsistencyResponse_Status int32 @@ -310,7 +310,7 @@ func (x CheckConsistencyResponse_Status) String() string { return proto.EnumName(CheckConsistencyResponse_Status_name, int32(x)) } func (CheckConsistencyResponse_Status) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{25, 0} + return fileDescriptor_api_fc904b6f390e813c, []int{25, 0} } // RequestHeader is supplied with every storage node request. @@ -331,7 +331,7 @@ func (m *RequestHeader) Reset() { *m = RequestHeader{} } func (m *RequestHeader) String() string { return proto.CompactTextString(m) } func (*RequestHeader) ProtoMessage() {} func (*RequestHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{0} + return fileDescriptor_api_fc904b6f390e813c, []int{0} } func (m *RequestHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -402,7 +402,7 @@ func (m *ResponseHeader) Reset() { *m = ResponseHeader{} } func (m *ResponseHeader) String() string { return proto.CompactTextString(m) } func (*ResponseHeader) ProtoMessage() {} func (*ResponseHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{1} + return fileDescriptor_api_fc904b6f390e813c, []int{1} } func (m *ResponseHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -436,7 +436,7 @@ func (m *GetRequest) Reset() { *m = GetRequest{} } func (m *GetRequest) String() string { return proto.CompactTextString(m) } func (*GetRequest) ProtoMessage() {} func (*GetRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{2} + return fileDescriptor_api_fc904b6f390e813c, []int{2} } func (m *GetRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -479,7 +479,7 @@ func (m *GetResponse) Reset() { *m = GetResponse{} } func (m *GetResponse) String() string { return proto.CompactTextString(m) } func (*GetResponse) ProtoMessage() {} func (*GetResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{3} + return fileDescriptor_api_fc904b6f390e813c, []int{3} } func (m *GetResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -522,7 +522,7 @@ func (m *PutRequest) Reset() { *m = PutRequest{} } func (m *PutRequest) String() string { return proto.CompactTextString(m) } func (*PutRequest) ProtoMessage() {} func (*PutRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{4} + return fileDescriptor_api_fc904b6f390e813c, []int{4} } func (m *PutRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -556,7 +556,7 @@ func (m *PutResponse) Reset() { *m = PutResponse{} } func (m *PutResponse) String() string { return proto.CompactTextString(m) } func (*PutResponse) ProtoMessage() {} func (*PutResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{5} + return fileDescriptor_api_fc904b6f390e813c, []int{5} } func (m *PutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -638,7 +638,7 @@ func (m *ConditionalPutRequest) Reset() { *m = ConditionalPutRequest{} } func (m *ConditionalPutRequest) String() string { return proto.CompactTextString(m) } func (*ConditionalPutRequest) ProtoMessage() {} func (*ConditionalPutRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{6} + return fileDescriptor_api_fc904b6f390e813c, []int{6} } func (m *ConditionalPutRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -673,7 +673,7 @@ func (m *ConditionalPutResponse) Reset() { *m = ConditionalPutResponse{} func (m *ConditionalPutResponse) String() string { return proto.CompactTextString(m) } func (*ConditionalPutResponse) ProtoMessage() {} func (*ConditionalPutResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{7} + return fileDescriptor_api_fc904b6f390e813c, []int{7} } func (m *ConditionalPutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -719,7 +719,7 @@ func (m *InitPutRequest) Reset() { *m = InitPutRequest{} } func (m *InitPutRequest) String() string { return proto.CompactTextString(m) } func (*InitPutRequest) ProtoMessage() {} func (*InitPutRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{8} + return fileDescriptor_api_fc904b6f390e813c, []int{8} } func (m *InitPutRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -753,7 +753,7 @@ func (m *InitPutResponse) Reset() { *m = InitPutResponse{} } func (m *InitPutResponse) String() string { return proto.CompactTextString(m) } func (*InitPutResponse) ProtoMessage() {} func (*InitPutResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{9} + return fileDescriptor_api_fc904b6f390e813c, []int{9} } func (m *InitPutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -793,7 +793,7 @@ func (m *IncrementRequest) Reset() { *m = IncrementRequest{} } func (m *IncrementRequest) String() string { return proto.CompactTextString(m) } func (*IncrementRequest) ProtoMessage() {} func (*IncrementRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{10} + return fileDescriptor_api_fc904b6f390e813c, []int{10} } func (m *IncrementRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -830,7 +830,7 @@ func (m *IncrementResponse) Reset() { *m = IncrementResponse{} } func (m *IncrementResponse) String() string { return proto.CompactTextString(m) } func (*IncrementResponse) ProtoMessage() {} func (*IncrementResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{11} + return fileDescriptor_api_fc904b6f390e813c, []int{11} } func (m *IncrementResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -864,7 +864,7 @@ func (m *DeleteRequest) Reset() { *m = DeleteRequest{} } func (m *DeleteRequest) String() string { return proto.CompactTextString(m) } func (*DeleteRequest) ProtoMessage() {} func (*DeleteRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{12} + return fileDescriptor_api_fc904b6f390e813c, []int{12} } func (m *DeleteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -898,7 +898,7 @@ func (m *DeleteResponse) Reset() { *m = DeleteResponse{} } func (m *DeleteResponse) String() string { return proto.CompactTextString(m) } func (*DeleteResponse) ProtoMessage() {} func (*DeleteResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{13} + return fileDescriptor_api_fc904b6f390e813c, []int{13} } func (m *DeleteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -950,7 +950,7 @@ func (m *DeleteRangeRequest) Reset() { *m = DeleteRangeRequest{} } func (m *DeleteRangeRequest) String() string { return proto.CompactTextString(m) } func (*DeleteRangeRequest) ProtoMessage() {} func (*DeleteRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{14} + return fileDescriptor_api_fc904b6f390e813c, []int{14} } func (m *DeleteRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -987,7 +987,7 @@ func (m *DeleteRangeResponse) Reset() { *m = DeleteRangeResponse{} } func (m *DeleteRangeResponse) String() string { return proto.CompactTextString(m) } func (*DeleteRangeResponse) ProtoMessage() {} func (*DeleteRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{15} + return fileDescriptor_api_fc904b6f390e813c, []int{15} } func (m *DeleteRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1042,7 +1042,7 @@ func (m *ClearRangeRequest) Reset() { *m = ClearRangeRequest{} } func (m *ClearRangeRequest) String() string { return proto.CompactTextString(m) } func (*ClearRangeRequest) ProtoMessage() {} func (*ClearRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{16} + return fileDescriptor_api_fc904b6f390e813c, []int{16} } func (m *ClearRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1076,7 +1076,7 @@ func (m *ClearRangeResponse) Reset() { *m = ClearRangeResponse{} } func (m *ClearRangeResponse) String() string { return proto.CompactTextString(m) } func (*ClearRangeResponse) ProtoMessage() {} func (*ClearRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{17} + return fileDescriptor_api_fc904b6f390e813c, []int{17} } func (m *ClearRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1117,7 +1117,7 @@ func (m *RevertRangeRequest) Reset() { *m = RevertRangeRequest{} } func (m *RevertRangeRequest) String() string { return proto.CompactTextString(m) } func (*RevertRangeRequest) ProtoMessage() {} func (*RevertRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{18} + return fileDescriptor_api_fc904b6f390e813c, []int{18} } func (m *RevertRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1151,7 +1151,7 @@ func (m *RevertRangeResponse) Reset() { *m = RevertRangeResponse{} } func (m *RevertRangeResponse) String() string { return proto.CompactTextString(m) } func (*RevertRangeResponse) ProtoMessage() {} func (*RevertRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{19} + return fileDescriptor_api_fc904b6f390e813c, []int{19} } func (m *RevertRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1202,7 +1202,7 @@ func (m *ScanRequest) Reset() { *m = ScanRequest{} } func (m *ScanRequest) String() string { return proto.CompactTextString(m) } func (*ScanRequest) ProtoMessage() {} func (*ScanRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{20} + return fileDescriptor_api_fc904b6f390e813c, []int{20} } func (m *ScanRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1254,7 +1254,7 @@ func (m *ScanResponse) Reset() { *m = ScanResponse{} } func (m *ScanResponse) String() string { return proto.CompactTextString(m) } func (*ScanResponse) ProtoMessage() {} func (*ScanResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{21} + return fileDescriptor_api_fc904b6f390e813c, []int{21} } func (m *ScanResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1305,7 +1305,7 @@ func (m *ReverseScanRequest) Reset() { *m = ReverseScanRequest{} } func (m *ReverseScanRequest) String() string { return proto.CompactTextString(m) } func (*ReverseScanRequest) ProtoMessage() {} func (*ReverseScanRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{22} + return fileDescriptor_api_fc904b6f390e813c, []int{22} } func (m *ReverseScanRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1357,7 +1357,7 @@ func (m *ReverseScanResponse) Reset() { *m = ReverseScanResponse{} } func (m *ReverseScanResponse) String() string { return proto.CompactTextString(m) } func (*ReverseScanResponse) ProtoMessage() {} func (*ReverseScanResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{23} + return fileDescriptor_api_fc904b6f390e813c, []int{23} } func (m *ReverseScanResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1410,7 +1410,7 @@ func (m *CheckConsistencyRequest) Reset() { *m = CheckConsistencyRequest func (m *CheckConsistencyRequest) String() string { return proto.CompactTextString(m) } func (*CheckConsistencyRequest) ProtoMessage() {} func (*CheckConsistencyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{24} + return fileDescriptor_api_fc904b6f390e813c, []int{24} } func (m *CheckConsistencyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1447,7 +1447,7 @@ func (m *CheckConsistencyResponse) Reset() { *m = CheckConsistencyRespon func (m *CheckConsistencyResponse) String() string { return proto.CompactTextString(m) } func (*CheckConsistencyResponse) ProtoMessage() {} func (*CheckConsistencyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{25} + return fileDescriptor_api_fc904b6f390e813c, []int{25} } func (m *CheckConsistencyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1491,7 +1491,7 @@ func (m *CheckConsistencyResponse_Result) Reset() { *m = CheckConsistenc func (m *CheckConsistencyResponse_Result) String() string { return proto.CompactTextString(m) } func (*CheckConsistencyResponse_Result) ProtoMessage() {} func (*CheckConsistencyResponse_Result) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{25, 0} + return fileDescriptor_api_fc904b6f390e813c, []int{25, 0} } func (m *CheckConsistencyResponse_Result) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1539,7 +1539,7 @@ func (m *RecomputeStatsRequest) Reset() { *m = RecomputeStatsRequest{} } func (m *RecomputeStatsRequest) String() string { return proto.CompactTextString(m) } func (*RecomputeStatsRequest) ProtoMessage() {} func (*RecomputeStatsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{26} + return fileDescriptor_api_fc904b6f390e813c, []int{26} } func (m *RecomputeStatsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1575,7 +1575,7 @@ func (m *RecomputeStatsResponse) Reset() { *m = RecomputeStatsResponse{} func (m *RecomputeStatsResponse) String() string { return proto.CompactTextString(m) } func (*RecomputeStatsResponse) ProtoMessage() {} func (*RecomputeStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{27} + return fileDescriptor_api_fc904b6f390e813c, []int{27} } func (m *RecomputeStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1672,7 +1672,7 @@ func (m *EndTxnRequest) Reset() { *m = EndTxnRequest{} } func (m *EndTxnRequest) String() string { return proto.CompactTextString(m) } func (*EndTxnRequest) ProtoMessage() {} func (*EndTxnRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{28} + return fileDescriptor_api_fc904b6f390e813c, []int{28} } func (m *EndTxnRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1718,7 +1718,7 @@ func (m *EndTxnResponse) Reset() { *m = EndTxnResponse{} } func (m *EndTxnResponse) String() string { return proto.CompactTextString(m) } func (*EndTxnResponse) ProtoMessage() {} func (*EndTxnResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{29} + return fileDescriptor_api_fc904b6f390e813c, []int{29} } func (m *EndTxnResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1779,7 +1779,7 @@ func (m *AdminSplitRequest) Reset() { *m = AdminSplitRequest{} } func (m *AdminSplitRequest) String() string { return proto.CompactTextString(m) } func (*AdminSplitRequest) ProtoMessage() {} func (*AdminSplitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{30} + return fileDescriptor_api_fc904b6f390e813c, []int{30} } func (m *AdminSplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1814,7 +1814,7 @@ func (m *AdminSplitResponse) Reset() { *m = AdminSplitResponse{} } func (m *AdminSplitResponse) String() string { return proto.CompactTextString(m) } func (*AdminSplitResponse) ProtoMessage() {} func (*AdminSplitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{31} + return fileDescriptor_api_fc904b6f390e813c, []int{31} } func (m *AdminSplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1853,7 +1853,7 @@ func (m *AdminUnsplitRequest) Reset() { *m = AdminUnsplitRequest{} } func (m *AdminUnsplitRequest) String() string { return proto.CompactTextString(m) } func (*AdminUnsplitRequest) ProtoMessage() {} func (*AdminUnsplitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{32} + return fileDescriptor_api_fc904b6f390e813c, []int{32} } func (m *AdminUnsplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1888,7 +1888,7 @@ func (m *AdminUnsplitResponse) Reset() { *m = AdminUnsplitResponse{} } func (m *AdminUnsplitResponse) String() string { return proto.CompactTextString(m) } func (*AdminUnsplitResponse) ProtoMessage() {} func (*AdminUnsplitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{33} + return fileDescriptor_api_fc904b6f390e813c, []int{33} } func (m *AdminUnsplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1931,7 +1931,7 @@ func (m *AdminMergeRequest) Reset() { *m = AdminMergeRequest{} } func (m *AdminMergeRequest) String() string { return proto.CompactTextString(m) } func (*AdminMergeRequest) ProtoMessage() {} func (*AdminMergeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{34} + return fileDescriptor_api_fc904b6f390e813c, []int{34} } func (m *AdminMergeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1966,7 +1966,7 @@ func (m *AdminMergeResponse) Reset() { *m = AdminMergeResponse{} } func (m *AdminMergeResponse) String() string { return proto.CompactTextString(m) } func (*AdminMergeResponse) ProtoMessage() {} func (*AdminMergeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{35} + return fileDescriptor_api_fc904b6f390e813c, []int{35} } func (m *AdminMergeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2004,7 +2004,7 @@ func (m *AdminTransferLeaseRequest) Reset() { *m = AdminTransferLeaseReq func (m *AdminTransferLeaseRequest) String() string { return proto.CompactTextString(m) } func (*AdminTransferLeaseRequest) ProtoMessage() {} func (*AdminTransferLeaseRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{36} + return fileDescriptor_api_fc904b6f390e813c, []int{36} } func (m *AdminTransferLeaseRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2037,7 +2037,7 @@ func (m *AdminTransferLeaseResponse) Reset() { *m = AdminTransferLeaseRe func (m *AdminTransferLeaseResponse) String() string { return proto.CompactTextString(m) } func (*AdminTransferLeaseResponse) ProtoMessage() {} func (*AdminTransferLeaseResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{37} + return fileDescriptor_api_fc904b6f390e813c, []int{37} } func (m *AdminTransferLeaseResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2072,7 +2072,7 @@ func (m *ReplicationChange) Reset() { *m = ReplicationChange{} } func (m *ReplicationChange) String() string { return proto.CompactTextString(m) } func (*ReplicationChange) ProtoMessage() {} func (*ReplicationChange) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{38} + return fileDescriptor_api_fc904b6f390e813c, []int{38} } func (m *ReplicationChange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2130,7 +2130,7 @@ func (m *AdminChangeReplicasRequest) Reset() { *m = AdminChangeReplicasR func (m *AdminChangeReplicasRequest) String() string { return proto.CompactTextString(m) } func (*AdminChangeReplicasRequest) ProtoMessage() {} func (*AdminChangeReplicasRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{39} + return fileDescriptor_api_fc904b6f390e813c, []int{39} } func (m *AdminChangeReplicasRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2165,7 +2165,7 @@ func (m *AdminChangeReplicasResponse) Reset() { *m = AdminChangeReplicas func (m *AdminChangeReplicasResponse) String() string { return proto.CompactTextString(m) } func (*AdminChangeReplicasResponse) ProtoMessage() {} func (*AdminChangeReplicasResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{40} + return fileDescriptor_api_fc904b6f390e813c, []int{40} } func (m *AdminChangeReplicasResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2202,7 +2202,7 @@ func (m *AdminRelocateRangeRequest) Reset() { *m = AdminRelocateRangeReq func (m *AdminRelocateRangeRequest) String() string { return proto.CompactTextString(m) } func (*AdminRelocateRangeRequest) ProtoMessage() {} func (*AdminRelocateRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{41} + return fileDescriptor_api_fc904b6f390e813c, []int{41} } func (m *AdminRelocateRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2235,7 +2235,7 @@ func (m *AdminRelocateRangeResponse) Reset() { *m = AdminRelocateRangeRe func (m *AdminRelocateRangeResponse) String() string { return proto.CompactTextString(m) } func (*AdminRelocateRangeResponse) ProtoMessage() {} func (*AdminRelocateRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{42} + return fileDescriptor_api_fc904b6f390e813c, []int{42} } func (m *AdminRelocateRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2274,7 +2274,7 @@ func (m *HeartbeatTxnRequest) Reset() { *m = HeartbeatTxnRequest{} } func (m *HeartbeatTxnRequest) String() string { return proto.CompactTextString(m) } func (*HeartbeatTxnRequest) ProtoMessage() {} func (*HeartbeatTxnRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{43} + return fileDescriptor_api_fc904b6f390e813c, []int{43} } func (m *HeartbeatTxnRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2311,7 +2311,7 @@ func (m *HeartbeatTxnResponse) Reset() { *m = HeartbeatTxnResponse{} } func (m *HeartbeatTxnResponse) String() string { return proto.CompactTextString(m) } func (*HeartbeatTxnResponse) ProtoMessage() {} func (*HeartbeatTxnResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{44} + return fileDescriptor_api_fc904b6f390e813c, []int{44} } func (m *HeartbeatTxnResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2349,7 +2349,7 @@ func (m *GCRequest) Reset() { *m = GCRequest{} } func (m *GCRequest) String() string { return proto.CompactTextString(m) } func (*GCRequest) ProtoMessage() {} func (*GCRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{45} + return fileDescriptor_api_fc904b6f390e813c, []int{45} } func (m *GCRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2383,7 +2383,7 @@ func (m *GCRequest_GCKey) Reset() { *m = GCRequest_GCKey{} } func (m *GCRequest_GCKey) String() string { return proto.CompactTextString(m) } func (*GCRequest_GCKey) ProtoMessage() {} func (*GCRequest_GCKey) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{45, 0} + return fileDescriptor_api_fc904b6f390e813c, []int{45, 0} } func (m *GCRequest_GCKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2417,7 +2417,7 @@ func (m *GCResponse) Reset() { *m = GCResponse{} } func (m *GCResponse) String() string { return proto.CompactTextString(m) } func (*GCResponse) ProtoMessage() {} func (*GCResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{46} + return fileDescriptor_api_fc904b6f390e813c, []int{46} } func (m *GCResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2486,7 +2486,7 @@ func (m *PushTxnRequest) Reset() { *m = PushTxnRequest{} } func (m *PushTxnRequest) String() string { return proto.CompactTextString(m) } func (*PushTxnRequest) ProtoMessage() {} func (*PushTxnRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{47} + return fileDescriptor_api_fc904b6f390e813c, []int{47} } func (m *PushTxnRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2529,7 +2529,7 @@ func (m *PushTxnResponse) Reset() { *m = PushTxnResponse{} } func (m *PushTxnResponse) String() string { return proto.CompactTextString(m) } func (*PushTxnResponse) ProtoMessage() {} func (*PushTxnResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{48} + return fileDescriptor_api_fc904b6f390e813c, []int{48} } func (m *PushTxnResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2576,7 +2576,7 @@ func (m *RecoverTxnRequest) Reset() { *m = RecoverTxnRequest{} } func (m *RecoverTxnRequest) String() string { return proto.CompactTextString(m) } func (*RecoverTxnRequest) ProtoMessage() {} func (*RecoverTxnRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{49} + return fileDescriptor_api_fc904b6f390e813c, []int{49} } func (m *RecoverTxnRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2612,7 +2612,7 @@ func (m *RecoverTxnResponse) Reset() { *m = RecoverTxnResponse{} } func (m *RecoverTxnResponse) String() string { return proto.CompactTextString(m) } func (*RecoverTxnResponse) ProtoMessage() {} func (*RecoverTxnResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{50} + return fileDescriptor_api_fc904b6f390e813c, []int{50} } func (m *RecoverTxnResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2656,7 +2656,7 @@ func (m *QueryTxnRequest) Reset() { *m = QueryTxnRequest{} } func (m *QueryTxnRequest) String() string { return proto.CompactTextString(m) } func (*QueryTxnRequest) ProtoMessage() {} func (*QueryTxnRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{51} + return fileDescriptor_api_fc904b6f390e813c, []int{51} } func (m *QueryTxnRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2700,7 +2700,7 @@ func (m *QueryTxnResponse) Reset() { *m = QueryTxnResponse{} } func (m *QueryTxnResponse) String() string { return proto.CompactTextString(m) } func (*QueryTxnResponse) ProtoMessage() {} func (*QueryTxnResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{52} + return fileDescriptor_api_fc904b6f390e813c, []int{52} } func (m *QueryTxnResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2760,7 +2760,7 @@ func (m *QueryIntentRequest) Reset() { *m = QueryIntentRequest{} } func (m *QueryIntentRequest) String() string { return proto.CompactTextString(m) } func (*QueryIntentRequest) ProtoMessage() {} func (*QueryIntentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{53} + return fileDescriptor_api_fc904b6f390e813c, []int{53} } func (m *QueryIntentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2796,7 +2796,7 @@ func (m *QueryIntentResponse) Reset() { *m = QueryIntentResponse{} } func (m *QueryIntentResponse) String() string { return proto.CompactTextString(m) } func (*QueryIntentResponse) ProtoMessage() {} func (*QueryIntentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{54} + return fileDescriptor_api_fc904b6f390e813c, []int{54} } func (m *QueryIntentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2843,7 +2843,7 @@ func (m *ResolveIntentRequest) Reset() { *m = ResolveIntentRequest{} } func (m *ResolveIntentRequest) String() string { return proto.CompactTextString(m) } func (*ResolveIntentRequest) ProtoMessage() {} func (*ResolveIntentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{55} + return fileDescriptor_api_fc904b6f390e813c, []int{55} } func (m *ResolveIntentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2878,7 +2878,7 @@ func (m *ResolveIntentResponse) Reset() { *m = ResolveIntentResponse{} } func (m *ResolveIntentResponse) String() string { return proto.CompactTextString(m) } func (*ResolveIntentResponse) ProtoMessage() {} func (*ResolveIntentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{56} + return fileDescriptor_api_fc904b6f390e813c, []int{56} } func (m *ResolveIntentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2929,7 +2929,7 @@ func (m *ResolveIntentRangeRequest) Reset() { *m = ResolveIntentRangeReq func (m *ResolveIntentRangeRequest) String() string { return proto.CompactTextString(m) } func (*ResolveIntentRangeRequest) ProtoMessage() {} func (*ResolveIntentRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{57} + return fileDescriptor_api_fc904b6f390e813c, []int{57} } func (m *ResolveIntentRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2964,7 +2964,7 @@ func (m *ResolveIntentRangeResponse) Reset() { *m = ResolveIntentRangeRe func (m *ResolveIntentRangeResponse) String() string { return proto.CompactTextString(m) } func (*ResolveIntentRangeResponse) ProtoMessage() {} func (*ResolveIntentRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{58} + return fileDescriptor_api_fc904b6f390e813c, []int{58} } func (m *ResolveIntentRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3001,7 +3001,7 @@ func (m *MergeRequest) Reset() { *m = MergeRequest{} } func (m *MergeRequest) String() string { return proto.CompactTextString(m) } func (*MergeRequest) ProtoMessage() {} func (*MergeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{59} + return fileDescriptor_api_fc904b6f390e813c, []int{59} } func (m *MergeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3035,7 +3035,7 @@ func (m *MergeResponse) Reset() { *m = MergeResponse{} } func (m *MergeResponse) String() string { return proto.CompactTextString(m) } func (*MergeResponse) ProtoMessage() {} func (*MergeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{60} + return fileDescriptor_api_fc904b6f390e813c, []int{60} } func (m *MergeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3080,7 +3080,7 @@ func (m *TruncateLogRequest) Reset() { *m = TruncateLogRequest{} } func (m *TruncateLogRequest) String() string { return proto.CompactTextString(m) } func (*TruncateLogRequest) ProtoMessage() {} func (*TruncateLogRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{61} + return fileDescriptor_api_fc904b6f390e813c, []int{61} } func (m *TruncateLogRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3114,7 +3114,7 @@ func (m *TruncateLogResponse) Reset() { *m = TruncateLogResponse{} } func (m *TruncateLogResponse) String() string { return proto.CompactTextString(m) } func (*TruncateLogResponse) ProtoMessage() {} func (*TruncateLogResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{62} + return fileDescriptor_api_fc904b6f390e813c, []int{62} } func (m *TruncateLogResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3158,7 +3158,7 @@ func (m *RequestLeaseRequest) Reset() { *m = RequestLeaseRequest{} } func (m *RequestLeaseRequest) String() string { return proto.CompactTextString(m) } func (*RequestLeaseRequest) ProtoMessage() {} func (*RequestLeaseRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{63} + return fileDescriptor_api_fc904b6f390e813c, []int{63} } func (m *RequestLeaseRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3207,7 +3207,7 @@ func (m *TransferLeaseRequest) Reset() { *m = TransferLeaseRequest{} } func (m *TransferLeaseRequest) String() string { return proto.CompactTextString(m) } func (*TransferLeaseRequest) ProtoMessage() {} func (*TransferLeaseRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{64} + return fileDescriptor_api_fc904b6f390e813c, []int{64} } func (m *TransferLeaseRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3244,7 +3244,7 @@ func (m *LeaseInfoRequest) Reset() { *m = LeaseInfoRequest{} } func (m *LeaseInfoRequest) String() string { return proto.CompactTextString(m) } func (*LeaseInfoRequest) ProtoMessage() {} func (*LeaseInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{65} + return fileDescriptor_api_fc904b6f390e813c, []int{65} } func (m *LeaseInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3281,7 +3281,7 @@ func (m *LeaseInfoResponse) Reset() { *m = LeaseInfoResponse{} } func (m *LeaseInfoResponse) String() string { return proto.CompactTextString(m) } func (*LeaseInfoResponse) ProtoMessage() {} func (*LeaseInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{66} + return fileDescriptor_api_fc904b6f390e813c, []int{66} } func (m *LeaseInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3316,7 +3316,7 @@ func (m *RequestLeaseResponse) Reset() { *m = RequestLeaseResponse{} } func (m *RequestLeaseResponse) String() string { return proto.CompactTextString(m) } func (*RequestLeaseResponse) ProtoMessage() {} func (*RequestLeaseResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{67} + return fileDescriptor_api_fc904b6f390e813c, []int{67} } func (m *RequestLeaseResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3371,7 +3371,7 @@ func (m *ComputeChecksumRequest) Reset() { *m = ComputeChecksumRequest{} func (m *ComputeChecksumRequest) String() string { return proto.CompactTextString(m) } func (*ComputeChecksumRequest) ProtoMessage() {} func (*ComputeChecksumRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{68} + return fileDescriptor_api_fc904b6f390e813c, []int{68} } func (m *ComputeChecksumRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3408,7 +3408,7 @@ func (m *ComputeChecksumResponse) Reset() { *m = ComputeChecksumResponse func (m *ComputeChecksumResponse) String() string { return proto.CompactTextString(m) } func (*ComputeChecksumResponse) ProtoMessage() {} func (*ComputeChecksumResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{69} + return fileDescriptor_api_fc904b6f390e813c, []int{69} } func (m *ComputeChecksumResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3448,7 +3448,7 @@ func (m *ExternalStorage) Reset() { *m = ExternalStorage{} } func (m *ExternalStorage) String() string { return proto.CompactTextString(m) } func (*ExternalStorage) ProtoMessage() {} func (*ExternalStorage) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{70} + return fileDescriptor_api_fc904b6f390e813c, []int{70} } func (m *ExternalStorage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3482,7 +3482,7 @@ func (m *ExternalStorage_LocalFilePath) Reset() { *m = ExternalStorage_L func (m *ExternalStorage_LocalFilePath) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_LocalFilePath) ProtoMessage() {} func (*ExternalStorage_LocalFilePath) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{70, 0} + return fileDescriptor_api_fc904b6f390e813c, []int{70, 0} } func (m *ExternalStorage_LocalFilePath) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3515,7 +3515,7 @@ func (m *ExternalStorage_Http) Reset() { *m = ExternalStorage_Http{} } func (m *ExternalStorage_Http) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_Http) ProtoMessage() {} func (*ExternalStorage_Http) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{70, 1} + return fileDescriptor_api_fc904b6f390e813c, []int{70, 1} } func (m *ExternalStorage_Http) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3555,7 +3555,7 @@ func (m *ExternalStorage_S3) Reset() { *m = ExternalStorage_S3{} } func (m *ExternalStorage_S3) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_S3) ProtoMessage() {} func (*ExternalStorage_S3) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{70, 2} + return fileDescriptor_api_fc904b6f390e813c, []int{70, 2} } func (m *ExternalStorage_S3) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3594,7 +3594,7 @@ func (m *ExternalStorage_GCS) Reset() { *m = ExternalStorage_GCS{} } func (m *ExternalStorage_GCS) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_GCS) ProtoMessage() {} func (*ExternalStorage_GCS) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{70, 3} + return fileDescriptor_api_fc904b6f390e813c, []int{70, 3} } func (m *ExternalStorage_GCS) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3630,7 +3630,7 @@ func (m *ExternalStorage_Azure) Reset() { *m = ExternalStorage_Azure{} } func (m *ExternalStorage_Azure) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_Azure) ProtoMessage() {} func (*ExternalStorage_Azure) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{70, 4} + return fileDescriptor_api_fc904b6f390e813c, []int{70, 4} } func (m *ExternalStorage_Azure) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3669,7 +3669,7 @@ func (m *ExternalStorage_Workload) Reset() { *m = ExternalStorage_Worklo func (m *ExternalStorage_Workload) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_Workload) ProtoMessage() {} func (*ExternalStorage_Workload) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{70, 5} + return fileDescriptor_api_fc904b6f390e813c, []int{70, 5} } func (m *ExternalStorage_Workload) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3709,7 +3709,7 @@ func (m *ExternalStorage_FileTable) Reset() { *m = ExternalStorage_FileT func (m *ExternalStorage_FileTable) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_FileTable) ProtoMessage() {} func (*ExternalStorage_FileTable) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{70, 6} + return fileDescriptor_api_fc904b6f390e813c, []int{70, 6} } func (m *ExternalStorage_FileTable) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3749,7 +3749,7 @@ func (m *WriteBatchRequest) Reset() { *m = WriteBatchRequest{} } func (m *WriteBatchRequest) String() string { return proto.CompactTextString(m) } func (*WriteBatchRequest) ProtoMessage() {} func (*WriteBatchRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{71} + return fileDescriptor_api_fc904b6f390e813c, []int{71} } func (m *WriteBatchRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3783,7 +3783,7 @@ func (m *WriteBatchResponse) Reset() { *m = WriteBatchResponse{} } func (m *WriteBatchResponse) String() string { return proto.CompactTextString(m) } func (*WriteBatchResponse) ProtoMessage() {} func (*WriteBatchResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{72} + return fileDescriptor_api_fc904b6f390e813c, []int{72} } func (m *WriteBatchResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3819,7 +3819,7 @@ func (m *FileEncryptionOptions) Reset() { *m = FileEncryptionOptions{} } func (m *FileEncryptionOptions) String() string { return proto.CompactTextString(m) } func (*FileEncryptionOptions) ProtoMessage() {} func (*FileEncryptionOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{73} + return fileDescriptor_api_fc904b6f390e813c, []int{73} } func (m *FileEncryptionOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3889,7 +3889,7 @@ func (m *ExportRequest) Reset() { *m = ExportRequest{} } func (m *ExportRequest) String() string { return proto.CompactTextString(m) } func (*ExportRequest) ProtoMessage() {} func (*ExportRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{74} + return fileDescriptor_api_fc904b6f390e813c, []int{74} } func (m *ExportRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3941,7 +3941,7 @@ func (m *BulkOpSummary) Reset() { *m = BulkOpSummary{} } func (m *BulkOpSummary) String() string { return proto.CompactTextString(m) } func (*BulkOpSummary) ProtoMessage() {} func (*BulkOpSummary) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{75} + return fileDescriptor_api_fc904b6f390e813c, []int{75} } func (m *BulkOpSummary) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3977,7 +3977,7 @@ func (m *ExportResponse) Reset() { *m = ExportResponse{} } func (m *ExportResponse) String() string { return proto.CompactTextString(m) } func (*ExportResponse) ProtoMessage() {} func (*ExportResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{76} + return fileDescriptor_api_fc904b6f390e813c, []int{76} } func (m *ExportResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4017,7 +4017,7 @@ func (m *ExportResponse_File) Reset() { *m = ExportResponse_File{} } func (m *ExportResponse_File) String() string { return proto.CompactTextString(m) } func (*ExportResponse_File) ProtoMessage() {} func (*ExportResponse_File) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{76, 0} + return fileDescriptor_api_fc904b6f390e813c, []int{76, 0} } func (m *ExportResponse_File) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4068,7 +4068,7 @@ func (m *ImportRequest) Reset() { *m = ImportRequest{} } func (m *ImportRequest) String() string { return proto.CompactTextString(m) } func (*ImportRequest) ProtoMessage() {} func (*ImportRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{77} + return fileDescriptor_api_fc904b6f390e813c, []int{77} } func (m *ImportRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4103,7 +4103,7 @@ func (m *ImportRequest_File) Reset() { *m = ImportRequest_File{} } func (m *ImportRequest_File) String() string { return proto.CompactTextString(m) } func (*ImportRequest_File) ProtoMessage() {} func (*ImportRequest_File) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{77, 0} + return fileDescriptor_api_fc904b6f390e813c, []int{77, 0} } func (m *ImportRequest_File) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4139,7 +4139,7 @@ func (m *ImportRequest_TableRekey) Reset() { *m = ImportRequest_TableRek func (m *ImportRequest_TableRekey) String() string { return proto.CompactTextString(m) } func (*ImportRequest_TableRekey) ProtoMessage() {} func (*ImportRequest_TableRekey) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{77, 1} + return fileDescriptor_api_fc904b6f390e813c, []int{77, 1} } func (m *ImportRequest_TableRekey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4174,7 +4174,7 @@ func (m *ImportResponse) Reset() { *m = ImportResponse{} } func (m *ImportResponse) String() string { return proto.CompactTextString(m) } func (*ImportResponse) ProtoMessage() {} func (*ImportResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{78} + return fileDescriptor_api_fc904b6f390e813c, []int{78} } func (m *ImportResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4212,7 +4212,7 @@ func (m *AdminScatterRequest) Reset() { *m = AdminScatterRequest{} } func (m *AdminScatterRequest) String() string { return proto.CompactTextString(m) } func (*AdminScatterRequest) ProtoMessage() {} func (*AdminScatterRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{79} + return fileDescriptor_api_fc904b6f390e813c, []int{79} } func (m *AdminScatterRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4249,7 +4249,7 @@ func (m *AdminScatterResponse) Reset() { *m = AdminScatterResponse{} } func (m *AdminScatterResponse) String() string { return proto.CompactTextString(m) } func (*AdminScatterResponse) ProtoMessage() {} func (*AdminScatterResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{80} + return fileDescriptor_api_fc904b6f390e813c, []int{80} } func (m *AdminScatterResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4282,7 +4282,7 @@ func (m *AdminScatterResponse_Range) Reset() { *m = AdminScatterResponse func (m *AdminScatterResponse_Range) String() string { return proto.CompactTextString(m) } func (*AdminScatterResponse_Range) ProtoMessage() {} func (*AdminScatterResponse_Range) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{80, 0} + return fileDescriptor_api_fc904b6f390e813c, []int{80, 0} } func (m *AdminScatterResponse_Range) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4327,7 +4327,7 @@ func (m *AdminVerifyProtectedTimestampRequest) Reset() { *m = AdminVerif func (m *AdminVerifyProtectedTimestampRequest) String() string { return proto.CompactTextString(m) } func (*AdminVerifyProtectedTimestampRequest) ProtoMessage() {} func (*AdminVerifyProtectedTimestampRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{81} + return fileDescriptor_api_fc904b6f390e813c, []int{81} } func (m *AdminVerifyProtectedTimestampRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4365,7 +4365,7 @@ func (m *AdminVerifyProtectedTimestampResponse) Reset() { *m = AdminVeri func (m *AdminVerifyProtectedTimestampResponse) String() string { return proto.CompactTextString(m) } func (*AdminVerifyProtectedTimestampResponse) ProtoMessage() {} func (*AdminVerifyProtectedTimestampResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{82} + return fileDescriptor_api_fc904b6f390e813c, []int{82} } func (m *AdminVerifyProtectedTimestampResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4418,7 +4418,7 @@ func (m *AddSSTableRequest) Reset() { *m = AddSSTableRequest{} } func (m *AddSSTableRequest) String() string { return proto.CompactTextString(m) } func (*AddSSTableRequest) ProtoMessage() {} func (*AddSSTableRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{83} + return fileDescriptor_api_fc904b6f390e813c, []int{83} } func (m *AddSSTableRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4452,7 +4452,7 @@ func (m *AddSSTableResponse) Reset() { *m = AddSSTableResponse{} } func (m *AddSSTableResponse) String() string { return proto.CompactTextString(m) } func (*AddSSTableResponse) ProtoMessage() {} func (*AddSSTableResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{84} + return fileDescriptor_api_fc904b6f390e813c, []int{84} } func (m *AddSSTableResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4496,7 +4496,7 @@ func (m *RefreshRequest) Reset() { *m = RefreshRequest{} } func (m *RefreshRequest) String() string { return proto.CompactTextString(m) } func (*RefreshRequest) ProtoMessage() {} func (*RefreshRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{85} + return fileDescriptor_api_fc904b6f390e813c, []int{85} } func (m *RefreshRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4530,7 +4530,7 @@ func (m *RefreshResponse) Reset() { *m = RefreshResponse{} } func (m *RefreshResponse) String() string { return proto.CompactTextString(m) } func (*RefreshResponse) ProtoMessage() {} func (*RefreshResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{86} + return fileDescriptor_api_fc904b6f390e813c, []int{86} } func (m *RefreshResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4569,7 +4569,7 @@ func (m *RefreshRangeRequest) Reset() { *m = RefreshRangeRequest{} } func (m *RefreshRangeRequest) String() string { return proto.CompactTextString(m) } func (*RefreshRangeRequest) ProtoMessage() {} func (*RefreshRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{87} + return fileDescriptor_api_fc904b6f390e813c, []int{87} } func (m *RefreshRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4603,7 +4603,7 @@ func (m *RefreshRangeResponse) Reset() { *m = RefreshRangeResponse{} } func (m *RefreshRangeResponse) String() string { return proto.CompactTextString(m) } func (*RefreshRangeResponse) ProtoMessage() {} func (*RefreshRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{88} + return fileDescriptor_api_fc904b6f390e813c, []int{88} } func (m *RefreshRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4652,7 +4652,7 @@ func (m *SubsumeRequest) Reset() { *m = SubsumeRequest{} } func (m *SubsumeRequest) String() string { return proto.CompactTextString(m) } func (*SubsumeRequest) ProtoMessage() {} func (*SubsumeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{89} + return fileDescriptor_api_fc904b6f390e813c, []int{89} } func (m *SubsumeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4701,7 +4701,7 @@ func (m *SubsumeResponse) Reset() { *m = SubsumeResponse{} } func (m *SubsumeResponse) String() string { return proto.CompactTextString(m) } func (*SubsumeResponse) ProtoMessage() {} func (*SubsumeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{90} + return fileDescriptor_api_fc904b6f390e813c, []int{90} } func (m *SubsumeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4736,7 +4736,7 @@ func (m *RangeStatsRequest) Reset() { *m = RangeStatsRequest{} } func (m *RangeStatsRequest) String() string { return proto.CompactTextString(m) } func (*RangeStatsRequest) ProtoMessage() {} func (*RangeStatsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{91} + return fileDescriptor_api_fc904b6f390e813c, []int{91} } func (m *RangeStatsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4778,7 +4778,7 @@ func (m *RangeStatsResponse) Reset() { *m = RangeStatsResponse{} } func (m *RangeStatsResponse) String() string { return proto.CompactTextString(m) } func (*RangeStatsResponse) ProtoMessage() {} func (*RangeStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{92} + return fileDescriptor_api_fc904b6f390e813c, []int{92} } func (m *RangeStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4861,7 +4861,7 @@ func (m *RequestUnion) Reset() { *m = RequestUnion{} } func (m *RequestUnion) String() string { return proto.CompactTextString(m) } func (*RequestUnion) ProtoMessage() {} func (*RequestUnion) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{93} + return fileDescriptor_api_fc904b6f390e813c, []int{93} } func (m *RequestUnion) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6311,7 +6311,7 @@ func (m *ResponseUnion) Reset() { *m = ResponseUnion{} } func (m *ResponseUnion) String() string { return proto.CompactTextString(m) } func (*ResponseUnion) ProtoMessage() {} func (*ResponseUnion) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{94} + return fileDescriptor_api_fc904b6f390e813c, []int{94} } func (m *ResponseUnion) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7846,7 +7846,7 @@ func (m *Header) Reset() { *m = Header{} } func (m *Header) String() string { return proto.CompactTextString(m) } func (*Header) ProtoMessage() {} func (*Header) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{95} + return fileDescriptor_api_fc904b6f390e813c, []int{95} } func (m *Header) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7884,7 +7884,7 @@ func (m *ClientRangeInfo) Reset() { *m = ClientRangeInfo{} } func (m *ClientRangeInfo) String() string { return proto.CompactTextString(m) } func (*ClientRangeInfo) ProtoMessage() {} func (*ClientRangeInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{96} + return fileDescriptor_api_fc904b6f390e813c, []int{96} } func (m *ClientRangeInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7920,7 +7920,7 @@ type BatchRequest struct { func (m *BatchRequest) Reset() { *m = BatchRequest{} } func (*BatchRequest) ProtoMessage() {} func (*BatchRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{97} + return fileDescriptor_api_fc904b6f390e813c, []int{97} } func (m *BatchRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7957,7 +7957,7 @@ type BatchResponse struct { func (m *BatchResponse) Reset() { *m = BatchResponse{} } func (*BatchResponse) ProtoMessage() {} func (*BatchResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{98} + return fileDescriptor_api_fc904b6f390e813c, []int{98} } func (m *BatchResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8031,7 +8031,7 @@ func (m *BatchResponse_Header) Reset() { *m = BatchResponse_Header{} } func (m *BatchResponse_Header) String() string { return proto.CompactTextString(m) } func (*BatchResponse_Header) ProtoMessage() {} func (*BatchResponse_Header) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{98, 0} + return fileDescriptor_api_fc904b6f390e813c, []int{98, 0} } func (m *BatchResponse_Header) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8069,7 +8069,7 @@ func (m *RangeLookupRequest) Reset() { *m = RangeLookupRequest{} } func (m *RangeLookupRequest) String() string { return proto.CompactTextString(m) } func (*RangeLookupRequest) ProtoMessage() {} func (*RangeLookupRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{99} + return fileDescriptor_api_fc904b6f390e813c, []int{99} } func (m *RangeLookupRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8107,7 +8107,7 @@ func (m *RangeLookupResponse) Reset() { *m = RangeLookupResponse{} } func (m *RangeLookupResponse) String() string { return proto.CompactTextString(m) } func (*RangeLookupResponse) ProtoMessage() {} func (*RangeLookupResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{100} + return fileDescriptor_api_fc904b6f390e813c, []int{100} } func (m *RangeLookupResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8146,7 +8146,7 @@ func (m *RangeFeedRequest) Reset() { *m = RangeFeedRequest{} } func (m *RangeFeedRequest) String() string { return proto.CompactTextString(m) } func (*RangeFeedRequest) ProtoMessage() {} func (*RangeFeedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{101} + return fileDescriptor_api_fc904b6f390e813c, []int{101} } func (m *RangeFeedRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8187,7 +8187,7 @@ func (m *RangeFeedValue) Reset() { *m = RangeFeedValue{} } func (m *RangeFeedValue) String() string { return proto.CompactTextString(m) } func (*RangeFeedValue) ProtoMessage() {} func (*RangeFeedValue) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{102} + return fileDescriptor_api_fc904b6f390e813c, []int{102} } func (m *RangeFeedValue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8228,7 +8228,7 @@ func (m *RangeFeedCheckpoint) Reset() { *m = RangeFeedCheckpoint{} } func (m *RangeFeedCheckpoint) String() string { return proto.CompactTextString(m) } func (*RangeFeedCheckpoint) ProtoMessage() {} func (*RangeFeedCheckpoint) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{103} + return fileDescriptor_api_fc904b6f390e813c, []int{103} } func (m *RangeFeedCheckpoint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8265,7 +8265,7 @@ func (m *RangeFeedError) Reset() { *m = RangeFeedError{} } func (m *RangeFeedError) String() string { return proto.CompactTextString(m) } func (*RangeFeedError) ProtoMessage() {} func (*RangeFeedError) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{104} + return fileDescriptor_api_fc904b6f390e813c, []int{104} } func (m *RangeFeedError) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8302,7 +8302,7 @@ func (m *RangeFeedEvent) Reset() { *m = RangeFeedEvent{} } func (m *RangeFeedEvent) String() string { return proto.CompactTextString(m) } func (*RangeFeedEvent) ProtoMessage() {} func (*RangeFeedEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{105} + return fileDescriptor_api_fc904b6f390e813c, []int{105} } func (m *RangeFeedEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8343,7 +8343,7 @@ func (m *GossipSubscriptionRequest) Reset() { *m = GossipSubscriptionReq func (m *GossipSubscriptionRequest) String() string { return proto.CompactTextString(m) } func (*GossipSubscriptionRequest) ProtoMessage() {} func (*GossipSubscriptionRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{106} + return fileDescriptor_api_fc904b6f390e813c, []int{106} } func (m *GossipSubscriptionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8383,7 +8383,7 @@ func (m *GossipSubscriptionEvent) Reset() { *m = GossipSubscriptionEvent func (m *GossipSubscriptionEvent) String() string { return proto.CompactTextString(m) } func (*GossipSubscriptionEvent) ProtoMessage() {} func (*GossipSubscriptionEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_api_9ee73df62b8c2c4a, []int{107} + return fileDescriptor_api_fc904b6f390e813c, []int{107} } func (m *GossipSubscriptionEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8408,6 +8408,81 @@ func (m *GossipSubscriptionEvent) XXX_DiscardUnknown() { var xxx_messageInfo_GossipSubscriptionEvent proto.InternalMessageInfo +// JoinNodeRequest is used to specify to the server node what the client's +// binary version is. If it's not compatible with the rest of the cluster, the +// join attempt is refused. +type JoinNodeRequest struct { + BinaryVersion *Version `protobuf:"bytes,1,opt,name=binary_version,json=binaryVersion,proto3" json:"binary_version,omitempty"` +} + +func (m *JoinNodeRequest) Reset() { *m = JoinNodeRequest{} } +func (m *JoinNodeRequest) String() string { return proto.CompactTextString(m) } +func (*JoinNodeRequest) ProtoMessage() {} +func (*JoinNodeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_api_fc904b6f390e813c, []int{108} +} +func (m *JoinNodeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JoinNodeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (dst *JoinNodeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_JoinNodeRequest.Merge(dst, src) +} +func (m *JoinNodeRequest) XXX_Size() int { + return m.Size() +} +func (m *JoinNodeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_JoinNodeRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_JoinNodeRequest proto.InternalMessageInfo + +// JoinNodeResponse informs the joining node what the cluster id is, what +// node id was allocated to it, and what store ID to use for its first store. It +// also informs the node what the current active version is. +type JoinNodeResponse struct { + ClusterID []byte `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + NodeID int32 `protobuf:"varint,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` + StoreID int32 `protobuf:"varint,3,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` + ActiveVersion *Version `protobuf:"bytes,4,opt,name=active_version,json=activeVersion,proto3" json:"active_version,omitempty"` +} + +func (m *JoinNodeResponse) Reset() { *m = JoinNodeResponse{} } +func (m *JoinNodeResponse) String() string { return proto.CompactTextString(m) } +func (*JoinNodeResponse) ProtoMessage() {} +func (*JoinNodeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_api_fc904b6f390e813c, []int{109} +} +func (m *JoinNodeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JoinNodeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (dst *JoinNodeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_JoinNodeResponse.Merge(dst, src) +} +func (m *JoinNodeResponse) XXX_Size() int { + return m.Size() +} +func (m *JoinNodeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_JoinNodeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_JoinNodeResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*RequestHeader)(nil), "cockroach.roachpb.RequestHeader") proto.RegisterType((*ResponseHeader)(nil), "cockroach.roachpb.ResponseHeader") @@ -8533,6 +8608,8 @@ func init() { proto.RegisterType((*RangeFeedEvent)(nil), "cockroach.roachpb.RangeFeedEvent") proto.RegisterType((*GossipSubscriptionRequest)(nil), "cockroach.roachpb.GossipSubscriptionRequest") proto.RegisterType((*GossipSubscriptionEvent)(nil), "cockroach.roachpb.GossipSubscriptionEvent") + proto.RegisterType((*JoinNodeRequest)(nil), "cockroach.roachpb.JoinNodeRequest") + proto.RegisterType((*JoinNodeResponse)(nil), "cockroach.roachpb.JoinNodeResponse") proto.RegisterEnum("cockroach.roachpb.ReadConsistencyType", ReadConsistencyType_name, ReadConsistencyType_value) proto.RegisterEnum("cockroach.roachpb.ScanFormat", ScanFormat_name, ScanFormat_value) proto.RegisterEnum("cockroach.roachpb.ChecksumMode", ChecksumMode_name, ChecksumMode_value) @@ -10455,6 +10532,9 @@ type InternalClient interface { RangeLookup(ctx context.Context, in *RangeLookupRequest, opts ...grpc.CallOption) (*RangeLookupResponse, error) RangeFeed(ctx context.Context, in *RangeFeedRequest, opts ...grpc.CallOption) (Internal_RangeFeedClient, error) GossipSubscription(ctx context.Context, in *GossipSubscriptionRequest, opts ...grpc.CallOption) (Internal_GossipSubscriptionClient, error) + // Join a bootstrapped cluster. If the target node is itself not part of a + // bootstrapped cluster, an appropriate error is returned. + Join(ctx context.Context, in *JoinNodeRequest, opts ...grpc.CallOption) (*JoinNodeResponse, error) } type internalClient struct { @@ -10547,12 +10627,24 @@ func (x *internalGossipSubscriptionClient) Recv() (*GossipSubscriptionEvent, err return m, nil } +func (c *internalClient) Join(ctx context.Context, in *JoinNodeRequest, opts ...grpc.CallOption) (*JoinNodeResponse, error) { + out := new(JoinNodeResponse) + err := c.cc.Invoke(ctx, "/cockroach.roachpb.Internal/Join", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // InternalServer is the server API for Internal service. type InternalServer interface { Batch(context.Context, *BatchRequest) (*BatchResponse, error) RangeLookup(context.Context, *RangeLookupRequest) (*RangeLookupResponse, error) RangeFeed(*RangeFeedRequest, Internal_RangeFeedServer) error GossipSubscription(*GossipSubscriptionRequest, Internal_GossipSubscriptionServer) error + // Join a bootstrapped cluster. If the target node is itself not part of a + // bootstrapped cluster, an appropriate error is returned. + Join(context.Context, *JoinNodeRequest) (*JoinNodeResponse, error) } func RegisterInternalServer(s *grpc.Server, srv InternalServer) { @@ -10637,6 +10729,24 @@ func (x *internalGossipSubscriptionServer) Send(m *GossipSubscriptionEvent) erro return x.ServerStream.SendMsg(m) } +func _Internal_Join_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(JoinNodeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(InternalServer).Join(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cockroach.roachpb.Internal/Join", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(InternalServer).Join(ctx, req.(*JoinNodeRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _Internal_serviceDesc = grpc.ServiceDesc{ ServiceName: "cockroach.roachpb.Internal", HandlerType: (*InternalServer)(nil), @@ -10649,6 +10759,10 @@ var _Internal_serviceDesc = grpc.ServiceDesc{ MethodName: "RangeLookup", Handler: _Internal_RangeLookup_Handler, }, + { + MethodName: "Join", + Handler: _Internal_Join_Handler, + }, }, Streams: []grpc.StreamDesc{ { @@ -17108,6 +17222,78 @@ func (m *GossipSubscriptionEvent) MarshalTo(dAtA []byte) (int, error) { return i, nil } +func (m *JoinNodeRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JoinNodeRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.BinaryVersion != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintApi(dAtA, i, uint64(m.BinaryVersion.Size())) + n274, err := m.BinaryVersion.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n274 + } + return i, nil +} + +func (m *JoinNodeResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JoinNodeResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.ClusterID) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintApi(dAtA, i, uint64(len(m.ClusterID))) + i += copy(dAtA[i:], m.ClusterID) + } + if m.NodeID != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintApi(dAtA, i, uint64(m.NodeID)) + } + if m.StoreID != 0 { + dAtA[i] = 0x18 + i++ + i = encodeVarintApi(dAtA, i, uint64(m.StoreID)) + } + if m.ActiveVersion != nil { + dAtA[i] = 0x22 + i++ + i = encodeVarintApi(dAtA, i, uint64(m.ActiveVersion.Size())) + n275, err := m.ActiveVersion.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n275 + } + return i, nil +} + func encodeVarintApi(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -20355,6 +20541,42 @@ func (m *GossipSubscriptionEvent) Size() (n int) { return n } +func (m *JoinNodeRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BinaryVersion != nil { + l = m.BinaryVersion.Size() + n += 1 + l + sovApi(uint64(l)) + } + return n +} + +func (m *JoinNodeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClusterID) + if l > 0 { + n += 1 + l + sovApi(uint64(l)) + } + if m.NodeID != 0 { + n += 1 + sovApi(uint64(m.NodeID)) + } + if m.StoreID != 0 { + n += 1 + sovApi(uint64(m.StoreID)) + } + if m.ActiveVersion != nil { + l = m.ActiveVersion.Size() + n += 1 + l + sovApi(uint64(l)) + } + return n +} + func sovApi(x uint64) (n int) { for { n++ @@ -39170,6 +39392,241 @@ func (m *GossipSubscriptionEvent) Unmarshal(dAtA []byte) error { } return nil } +func (m *JoinNodeRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: JoinNodeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JoinNodeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BinaryVersion", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BinaryVersion == nil { + m.BinaryVersion = &Version{} + } + if err := m.BinaryVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JoinNodeResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: JoinNodeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JoinNodeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClusterID = append(m.ClusterID[:0], dAtA[iNdEx:postIndex]...) + if m.ClusterID == nil { + m.ClusterID = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType) + } + m.NodeID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NodeID |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreID", wireType) + } + m.StoreID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StoreID |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ActiveVersion", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ActiveVersion == nil { + m.ActiveVersion = &Version{} + } + if err := m.ActiveVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipApi(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 @@ -39275,500 +39732,508 @@ var ( ErrIntOverflowApi = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("roachpb/api.proto", fileDescriptor_api_9ee73df62b8c2c4a) } - -var fileDescriptor_api_9ee73df62b8c2c4a = []byte{ - // 7861 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7d, 0x6f, 0x6c, 0x23, 0xc9, - 0x95, 0x9f, 0x9a, 0xa4, 0x24, 0xf2, 0x91, 0xa2, 0x5a, 0x25, 0xcd, 0x0c, 0x47, 0xb3, 0x3b, 0xd2, - 0x70, 0xe7, 0xbf, 0x77, 0xa5, 0x9d, 0x99, 0xdd, 0xec, 0x7a, 0x67, 0xbd, 0xb6, 0x44, 0x71, 0x86, - 0x92, 0x46, 0x1a, 0x4d, 0x93, 0x9a, 0xf1, 0xae, 0xed, 0xb4, 0x5b, 0xdd, 0x25, 0xaa, 0x2d, 0xb2, - 0x9b, 0xd3, 0xdd, 0xd4, 0x9f, 0x01, 0x02, 0x38, 0xff, 0xe0, 0xc0, 0x09, 0x16, 0xf9, 0x90, 0x04, - 0x41, 0x1c, 0x67, 0x17, 0x70, 0x10, 0x07, 0x30, 0x36, 0xc8, 0xd7, 0x04, 0xce, 0x9f, 0x0f, 0x0e, - 0xb2, 0x67, 0xf8, 0x00, 0xdf, 0x01, 0x77, 0x36, 0x0e, 0x38, 0xe1, 0x3c, 0x06, 0x0e, 0x87, 0xfb, - 0x70, 0xc0, 0xdd, 0x87, 0x3b, 0x60, 0x81, 0x3b, 0x1c, 0xea, 0x4f, 0xff, 0x23, 0x9b, 0x14, 0xa5, - 0xed, 0xbd, 0x5b, 0xc0, 0x5f, 0x08, 0xf6, 0xab, 0x7a, 0xaf, 0xab, 0x5e, 0x55, 0xbd, 0x7a, 0xbf, - 0xaa, 0x57, 0xd5, 0x30, 0x61, 0x99, 0x8a, 0xba, 0xd3, 0xda, 0x9a, 0x57, 0x5a, 0xfa, 0x5c, 0xcb, - 0x32, 0x1d, 0x13, 0x4d, 0xa8, 0xa6, 0xba, 0x4b, 0xc9, 0x73, 0x3c, 0x71, 0xfa, 0xe6, 0xee, 0xde, - 0xfc, 0xee, 0x9e, 0x8d, 0xad, 0x3d, 0x6c, 0xcd, 0xab, 0xa6, 0xa1, 0xb6, 0x2d, 0x0b, 0x1b, 0xea, - 0xe1, 0x7c, 0xc3, 0x54, 0x77, 0xe9, 0x8f, 0x6e, 0xd4, 0x19, 0xfb, 0x34, 0x72, 0x25, 0x6a, 0x8a, - 0xa3, 0x70, 0xda, 0x94, 0x4b, 0xc3, 0x96, 0x65, 0x5a, 0x36, 0xa7, 0x9e, 0x75, 0xa9, 0x4d, 0xec, - 0x28, 0x81, 0xdc, 0x17, 0x6c, 0xc7, 0xb4, 0x94, 0x3a, 0x9e, 0xc7, 0x46, 0x5d, 0x37, 0x30, 0xc9, - 0xb0, 0xa7, 0xaa, 0x3c, 0xf1, 0x85, 0xc8, 0xc4, 0x3b, 0x3c, 0xb5, 0xd0, 0x76, 0xf4, 0xc6, 0xfc, - 0x4e, 0x43, 0x9d, 0x77, 0xf4, 0x26, 0xb6, 0x1d, 0xa5, 0xd9, 0xe2, 0x29, 0xb3, 0x34, 0xc5, 0xb1, - 0x14, 0x55, 0x37, 0xea, 0xf3, 0x16, 0x56, 0x4d, 0x4b, 0xc3, 0x9a, 0x6c, 0xb7, 0x14, 0xc3, 0x2d, - 0x64, 0xdd, 0xac, 0x9b, 0xf4, 0xef, 0x3c, 0xf9, 0xc7, 0xa8, 0xc5, 0x1f, 0x0b, 0x30, 0x26, 0xe1, - 0xa7, 0x6d, 0x6c, 0x3b, 0x15, 0xac, 0x68, 0xd8, 0x42, 0xe7, 0x21, 0xb9, 0x8b, 0x0f, 0x0b, 0xc9, - 0x59, 0xe1, 0x7a, 0x6e, 0x71, 0xf4, 0x93, 0xa3, 0x99, 0xe4, 0x2a, 0x3e, 0x94, 0x08, 0x0d, 0xcd, - 0xc2, 0x28, 0x36, 0x34, 0x99, 0x24, 0xa7, 0xc2, 0xc9, 0x23, 0xd8, 0xd0, 0x56, 0xf1, 0x21, 0xfa, - 0x3a, 0xa4, 0x6d, 0x22, 0xcd, 0x50, 0x71, 0x61, 0x78, 0x56, 0xb8, 0x3e, 0xbc, 0xf8, 0x95, 0x4f, - 0x8e, 0x66, 0xde, 0xae, 0xeb, 0xce, 0x4e, 0x7b, 0x6b, 0x4e, 0x35, 0x9b, 0xf3, 0x9e, 0xf6, 0xb5, - 0x2d, 0xff, 0xff, 0x7c, 0x6b, 0xb7, 0x3e, 0xdf, 0x59, 0xf3, 0xb9, 0xda, 0x81, 0x51, 0xc5, 0x4f, - 0x25, 0x4f, 0xe2, 0x5b, 0xa9, 0x3f, 0xf9, 0x70, 0x46, 0x58, 0x49, 0xa5, 0x05, 0x31, 0xb1, 0x92, - 0x4a, 0x27, 0xc4, 0x64, 0xf1, 0x07, 0x49, 0xc8, 0x4b, 0xd8, 0x6e, 0x99, 0x86, 0x8d, 0x79, 0xf9, - 0x5f, 0x85, 0xa4, 0x73, 0x60, 0xd0, 0xf2, 0x67, 0x6f, 0x5f, 0x9c, 0xeb, 0x6a, 0xed, 0xb9, 0x9a, - 0xa5, 0x18, 0xb6, 0xa2, 0x3a, 0xba, 0x69, 0x48, 0x24, 0x2b, 0x7a, 0x13, 0xb2, 0x16, 0xb6, 0xdb, - 0x4d, 0x4c, 0xd5, 0x45, 0xab, 0x96, 0xbd, 0x7d, 0x2e, 0x82, 0xb3, 0xda, 0x52, 0x0c, 0x09, 0x58, - 0x5e, 0xf2, 0x1f, 0x9d, 0x87, 0xb4, 0xd1, 0x6e, 0x12, 0x85, 0xd8, 0xb4, 0xba, 0x49, 0x69, 0xd4, - 0x68, 0x37, 0x57, 0xf1, 0xa1, 0x8d, 0xbe, 0x0a, 0x67, 0x35, 0xdc, 0xb2, 0xb0, 0xaa, 0x38, 0x58, - 0x93, 0x2d, 0xc5, 0xa8, 0x63, 0x59, 0x37, 0xb6, 0x4d, 0xbb, 0x30, 0x32, 0x9b, 0xbc, 0x9e, 0xbd, - 0xfd, 0x42, 0x84, 0x7c, 0x89, 0xe4, 0x5a, 0x36, 0xb6, 0xcd, 0xc5, 0xd4, 0xc7, 0x47, 0x33, 0x43, - 0xd2, 0x94, 0x2f, 0xc1, 0x4b, 0xb2, 0x51, 0x15, 0xc6, 0x78, 0x71, 0x2d, 0xac, 0xd8, 0xa6, 0x51, - 0x18, 0x9d, 0x15, 0xae, 0xe7, 0x6f, 0xcf, 0x45, 0x09, 0x0c, 0xa9, 0x86, 0x3c, 0xb6, 0x9b, 0x58, - 0xa2, 0x5c, 0x52, 0xce, 0x0a, 0x3c, 0xa1, 0x0b, 0x90, 0x21, 0x35, 0xd9, 0x3a, 0x74, 0xb0, 0x5d, - 0x48, 0xd3, 0xaa, 0x90, 0xaa, 0x2d, 0x92, 0xe7, 0xe2, 0x3b, 0x90, 0x0b, 0xb2, 0x22, 0x04, 0x79, - 0xa9, 0x5c, 0xdd, 0x5c, 0x2b, 0xcb, 0x9b, 0xeb, 0xab, 0xeb, 0x0f, 0x9f, 0xac, 0x8b, 0x43, 0x68, - 0x0a, 0x44, 0x4e, 0x5b, 0x2d, 0xbf, 0x2b, 0x3f, 0x58, 0x5e, 0x5b, 0xae, 0x89, 0xc2, 0x74, 0xea, - 0x5f, 0xfc, 0xe0, 0xe2, 0x50, 0xf1, 0x31, 0xc0, 0x7d, 0xec, 0xf0, 0x6e, 0x86, 0x16, 0x61, 0x64, - 0x87, 0x96, 0xa7, 0x20, 0x50, 0x4d, 0xcf, 0x46, 0x16, 0x3c, 0xd0, 0x25, 0x17, 0xd3, 0x44, 0x1b, - 0x3f, 0x3f, 0x9a, 0x11, 0x24, 0xce, 0xc9, 0x7a, 0x42, 0xf1, 0xff, 0x08, 0x90, 0xa5, 0x82, 0x59, - 0x2d, 0x51, 0xa9, 0x43, 0xf2, 0xa5, 0x63, 0x55, 0xd2, 0x2d, 0x1a, 0xcd, 0xc1, 0xf0, 0x9e, 0xd2, - 0x68, 0xe3, 0x42, 0x82, 0xca, 0x28, 0x44, 0xc8, 0x78, 0x4c, 0xd2, 0x25, 0x96, 0x0d, 0xdd, 0x85, - 0x9c, 0x6e, 0x38, 0xd8, 0x70, 0x64, 0xc6, 0x96, 0x3c, 0x86, 0x2d, 0xcb, 0x72, 0xd3, 0x87, 0xe2, - 0xff, 0x14, 0x00, 0x36, 0xda, 0x71, 0xaa, 0x06, 0xbd, 0x36, 0x60, 0xf9, 0x79, 0x1f, 0xe3, 0xb5, - 0x38, 0x0b, 0x23, 0xba, 0xd1, 0xd0, 0x0d, 0x56, 0xfe, 0xb4, 0xc4, 0x9f, 0xd0, 0x14, 0x0c, 0x6f, - 0x35, 0x74, 0x43, 0xa3, 0xa3, 0x22, 0x2d, 0xb1, 0x07, 0xae, 0x7e, 0x09, 0xb2, 0xb4, 0xec, 0x31, - 0x6a, 0xbf, 0xf8, 0xb3, 0x04, 0x9c, 0x29, 0x99, 0x86, 0xa6, 0x93, 0xe1, 0xa9, 0x34, 0x3e, 0x17, - 0xba, 0x59, 0x81, 0xc0, 0x40, 0x94, 0xf1, 0x41, 0x6b, 0xc0, 0x96, 0x46, 0x3e, 0x57, 0xf9, 0xa0, - 0x45, 0x69, 0xd1, 0xfa, 0x44, 0xaf, 0xc1, 0x39, 0xa5, 0xd1, 0x30, 0xf7, 0x65, 0x7d, 0x5b, 0xd6, - 0x4c, 0x6c, 0xcb, 0x86, 0xe9, 0xc8, 0xf8, 0x40, 0xb7, 0x1d, 0x6a, 0x56, 0xd2, 0xd2, 0x24, 0x4d, - 0x5e, 0xde, 0x5e, 0x32, 0xb1, 0xbd, 0x6e, 0x3a, 0x65, 0x92, 0x44, 0xc6, 0x2c, 0x29, 0x0c, 0x1b, - 0xb3, 0x23, 0xc4, 0x20, 0x4b, 0x69, 0x7c, 0xd0, 0xa2, 0x63, 0x96, 0x37, 0xd1, 0x37, 0xe0, 0x6c, - 0xa7, 0x36, 0xe3, 0x6c, 0xad, 0xdf, 0x15, 0x20, 0xbf, 0x6c, 0xe8, 0xce, 0xe7, 0xa2, 0x99, 0x3c, - 0xd5, 0x26, 0x83, 0xaa, 0xbd, 0x09, 0xe2, 0xb6, 0xa2, 0x37, 0x1e, 0x1a, 0x35, 0xb3, 0xb9, 0x65, - 0x3b, 0xa6, 0x81, 0x6d, 0xae, 0xfb, 0x2e, 0x3a, 0xd7, 0xd9, 0x63, 0x18, 0xf7, 0xea, 0x14, 0xa7, - 0xb2, 0x9e, 0x81, 0xb8, 0x6c, 0xa8, 0x16, 0x6e, 0x62, 0x23, 0x56, 0x6d, 0xbd, 0x00, 0x19, 0xdd, - 0x95, 0x4b, 0x35, 0x96, 0x94, 0x7c, 0x02, 0xaf, 0x53, 0x1b, 0x26, 0x02, 0xef, 0x8e, 0xd3, 0x5c, - 0x92, 0x89, 0x03, 0xef, 0xcb, 0x7e, 0x7b, 0x91, 0x89, 0x03, 0xef, 0x33, 0xf3, 0xf6, 0x2e, 0x8c, - 0x2d, 0xe1, 0x06, 0x76, 0x70, 0xfc, 0xb6, 0x7f, 0x13, 0xf2, 0xae, 0xe8, 0x38, 0x1b, 0xe9, 0xfb, - 0x02, 0x20, 0x2e, 0x97, 0xcc, 0xb8, 0x71, 0xb6, 0xd3, 0x0c, 0x71, 0x33, 0x9c, 0xb6, 0x65, 0x30, +func init() { proto.RegisterFile("roachpb/api.proto", fileDescriptor_api_fc904b6f390e813c) } + +var fileDescriptor_api_fc904b6f390e813c = []byte{ + // 7989 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7d, 0x6f, 0x6c, 0x1b, 0x49, + 0x96, 0x9f, 0x9a, 0xa4, 0x24, 0xf2, 0x91, 0xa2, 0xa8, 0x92, 0x6c, 0xd3, 0x9a, 0x19, 0x4b, 0xa6, + 0xff, 0x8e, 0x77, 0x47, 0x1a, 0xdb, 0x3b, 0x99, 0xb9, 0xf1, 0xdc, 0xec, 0x49, 0x14, 0x6d, 0x52, + 0xb2, 0x64, 0xb9, 0x49, 0xd9, 0x3b, 0x73, 0xbb, 0xe9, 0x6d, 0x75, 0x97, 0xa8, 0x5e, 0x91, 0xdd, + 0x74, 0x77, 0x53, 0x7f, 0x0c, 0x04, 0xb8, 0xfc, 0x01, 0x2e, 0xb8, 0x04, 0x8b, 0x7c, 0x48, 0x82, + 0x20, 0x97, 0xcb, 0x0e, 0x70, 0x41, 0x2e, 0xc0, 0x61, 0x83, 0x7c, 0x4d, 0x70, 0xf9, 0xf3, 0xe1, + 0x82, 0x6c, 0x0e, 0x17, 0x60, 0x13, 0x20, 0xb9, 0x45, 0x80, 0x08, 0x39, 0x2d, 0x10, 0x04, 0xf9, + 0x10, 0x20, 0xf9, 0x90, 0x00, 0x03, 0x24, 0x08, 0xea, 0x5f, 0xff, 0x21, 0x9b, 0x14, 0xe5, 0xed, + 0xc9, 0x0d, 0x70, 0x5f, 0x08, 0xf6, 0xab, 0x7a, 0xaf, 0xab, 0x5e, 0x55, 0xbd, 0x7a, 0xbf, 0xaa, + 0x57, 0xd5, 0x30, 0x63, 0x5b, 0xaa, 0xb6, 0xdf, 0xd9, 0x5d, 0x56, 0x3b, 0xc6, 0x52, 0xc7, 0xb6, + 0x5c, 0x0b, 0xcd, 0x68, 0x96, 0x76, 0x40, 0xc9, 0x4b, 0x3c, 0x71, 0xfe, 0xde, 0xc1, 0xe1, 0xf2, + 0xc1, 0xa1, 0x83, 0xed, 0x43, 0x6c, 0x2f, 0x6b, 0x96, 0xa9, 0x75, 0x6d, 0x1b, 0x9b, 0xda, 0xc9, + 0x72, 0xcb, 0xd2, 0x0e, 0xe8, 0x8f, 0x61, 0x36, 0x19, 0xfb, 0x3c, 0x12, 0x12, 0x75, 0xd5, 0x55, + 0x39, 0x6d, 0x4e, 0xd0, 0xb0, 0x6d, 0x5b, 0xb6, 0xc3, 0xa9, 0x97, 0x05, 0xb5, 0x8d, 0x5d, 0x35, + 0x90, 0xfb, 0x2d, 0xc7, 0xb5, 0x6c, 0xb5, 0x89, 0x97, 0xb1, 0xd9, 0x34, 0x4c, 0x4c, 0x32, 0x1c, + 0x6a, 0x1a, 0x4f, 0x7c, 0x3b, 0x32, 0xf1, 0x21, 0x4f, 0x2d, 0x76, 0x5d, 0xa3, 0xb5, 0xbc, 0xdf, + 0xd2, 0x96, 0x5d, 0xa3, 0x8d, 0x1d, 0x57, 0x6d, 0x77, 0x78, 0xca, 0x22, 0x4d, 0x71, 0x6d, 0x55, + 0x33, 0xcc, 0xe6, 0xb2, 0x8d, 0x35, 0xcb, 0xd6, 0xb1, 0xae, 0x38, 0x1d, 0xd5, 0x14, 0x85, 0x6c, + 0x5a, 0x4d, 0x8b, 0xfe, 0x5d, 0x26, 0xff, 0x18, 0xb5, 0xf4, 0x7b, 0x12, 0x4c, 0xc9, 0xf8, 0x55, + 0x17, 0x3b, 0x6e, 0x15, 0xab, 0x3a, 0xb6, 0xd1, 0x55, 0x48, 0x1e, 0xe0, 0x93, 0x62, 0x72, 0x51, + 0xba, 0x9b, 0x5b, 0x9d, 0xfc, 0xf2, 0x74, 0x21, 0xb9, 0x81, 0x4f, 0x64, 0x42, 0x43, 0x8b, 0x30, + 0x89, 0x4d, 0x5d, 0x21, 0xc9, 0xa9, 0x70, 0xf2, 0x04, 0x36, 0xf5, 0x0d, 0x7c, 0x82, 0xbe, 0x0b, + 0x69, 0x87, 0x48, 0x33, 0x35, 0x5c, 0x1c, 0x5f, 0x94, 0xee, 0x8e, 0xaf, 0xfe, 0xca, 0x97, 0xa7, + 0x0b, 0x9f, 0x34, 0x0d, 0x77, 0xbf, 0xbb, 0xbb, 0xa4, 0x59, 0xed, 0x65, 0x4f, 0xfb, 0xfa, 0xae, + 0xff, 0x7f, 0xb9, 0x73, 0xd0, 0x5c, 0xee, 0xad, 0xf9, 0x52, 0xe3, 0xd8, 0xac, 0xe3, 0x57, 0xb2, + 0x27, 0xf1, 0xe3, 0xd4, 0x7f, 0xfd, 0x62, 0x41, 0x5a, 0x4f, 0xa5, 0xa5, 0x42, 0x62, 0x3d, 0x95, + 0x4e, 0x14, 0x92, 0xa5, 0xdf, 0x4e, 0x42, 0x5e, 0xc6, 0x4e, 0xc7, 0x32, 0x1d, 0xcc, 0xcb, 0xff, + 0x3e, 0x24, 0xdd, 0x63, 0x93, 0x96, 0x3f, 0xfb, 0xe0, 0xda, 0x52, 0x5f, 0x6b, 0x2f, 0x35, 0x6c, + 0xd5, 0x74, 0x54, 0xcd, 0x35, 0x2c, 0x53, 0x26, 0x59, 0xd1, 0x47, 0x90, 0xb5, 0xb1, 0xd3, 0x6d, + 0x63, 0xaa, 0x2e, 0x5a, 0xb5, 0xec, 0x83, 0x2b, 0x11, 0x9c, 0xf5, 0x8e, 0x6a, 0xca, 0xc0, 0xf2, + 0x92, 0xff, 0xe8, 0x2a, 0xa4, 0xcd, 0x6e, 0x9b, 0x28, 0xc4, 0xa1, 0xd5, 0x4d, 0xca, 0x93, 0x66, + 0xb7, 0xbd, 0x81, 0x4f, 0x1c, 0xf4, 0x1d, 0xb8, 0xac, 0xe3, 0x8e, 0x8d, 0x35, 0xd5, 0xc5, 0xba, + 0x62, 0xab, 0x66, 0x13, 0x2b, 0x86, 0xb9, 0x67, 0x39, 0xc5, 0x89, 0xc5, 0xe4, 0xdd, 0xec, 0x83, + 0xb7, 0x23, 0xe4, 0xcb, 0x24, 0x57, 0xcd, 0xdc, 0xb3, 0x56, 0x53, 0x3f, 0x39, 0x5d, 0x18, 0x93, + 0xe7, 0x7c, 0x09, 0x5e, 0x92, 0x83, 0xea, 0x30, 0xc5, 0x8b, 0x6b, 0x63, 0xd5, 0xb1, 0xcc, 0xe2, + 0xe4, 0xa2, 0x74, 0x37, 0xff, 0x60, 0x29, 0x4a, 0x60, 0x48, 0x35, 0xe4, 0xb1, 0xdb, 0xc6, 0x32, + 0xe5, 0x92, 0x73, 0x76, 0xe0, 0x09, 0xbd, 0x05, 0x19, 0x52, 0x93, 0xdd, 0x13, 0x17, 0x3b, 0xc5, + 0x34, 0xad, 0x0a, 0xa9, 0xda, 0x2a, 0x79, 0x2e, 0x7d, 0x0a, 0xb9, 0x20, 0x2b, 0x42, 0x90, 0x97, + 0x2b, 0xf5, 0x9d, 0xcd, 0x8a, 0xb2, 0xb3, 0xb5, 0xb1, 0xf5, 0xec, 0xe5, 0x56, 0x61, 0x0c, 0xcd, + 0x41, 0x81, 0xd3, 0x36, 0x2a, 0x9f, 0x29, 0x4f, 0x6b, 0x9b, 0xb5, 0x46, 0x41, 0x9a, 0x4f, 0xfd, + 0xe5, 0xdf, 0xbe, 0x36, 0x56, 0x7a, 0x01, 0xf0, 0x04, 0xbb, 0xbc, 0x9b, 0xa1, 0x55, 0x98, 0xd8, + 0xa7, 0xe5, 0x29, 0x4a, 0x54, 0xd3, 0x8b, 0x91, 0x05, 0x0f, 0x74, 0xc9, 0xd5, 0x34, 0xd1, 0xc6, + 0x4f, 0x4f, 0x17, 0x24, 0x99, 0x73, 0xb2, 0x9e, 0x50, 0xfa, 0xe7, 0x12, 0x64, 0xa9, 0x60, 0x56, + 0x4b, 0x54, 0xee, 0x91, 0x7c, 0xfd, 0x5c, 0x95, 0xf4, 0x8b, 0x46, 0x4b, 0x30, 0x7e, 0xa8, 0xb6, + 0xba, 0xb8, 0x98, 0xa0, 0x32, 0x8a, 0x11, 0x32, 0x5e, 0x90, 0x74, 0x99, 0x65, 0x43, 0x8f, 0x20, + 0x67, 0x98, 0x2e, 0x36, 0x5d, 0x85, 0xb1, 0x25, 0xcf, 0x61, 0xcb, 0xb2, 0xdc, 0xf4, 0xa1, 0xf4, + 0x4f, 0x24, 0x80, 0xed, 0x6e, 0x9c, 0xaa, 0x41, 0xdf, 0x1a, 0xb1, 0xfc, 0xbc, 0x8f, 0xf1, 0x5a, + 0x5c, 0x86, 0x09, 0xc3, 0x6c, 0x19, 0x26, 0x2b, 0x7f, 0x5a, 0xe6, 0x4f, 0x68, 0x0e, 0xc6, 0x77, + 0x5b, 0x86, 0xa9, 0xd3, 0x51, 0x91, 0x96, 0xd9, 0x03, 0x57, 0xbf, 0x0c, 0x59, 0x5a, 0xf6, 0x18, + 0xb5, 0x5f, 0xfa, 0xc3, 0x04, 0x5c, 0x2a, 0x5b, 0xa6, 0x6e, 0x90, 0xe1, 0xa9, 0xb6, 0xbe, 0x16, + 0xba, 0x59, 0x87, 0xc0, 0x40, 0x54, 0xf0, 0x71, 0x67, 0xc4, 0x96, 0x46, 0x3e, 0x57, 0xe5, 0xb8, + 0x43, 0x69, 0xd1, 0xfa, 0x44, 0xdf, 0x82, 0x2b, 0x6a, 0xab, 0x65, 0x1d, 0x29, 0xc6, 0x9e, 0xa2, + 0x5b, 0xd8, 0x51, 0x4c, 0xcb, 0x55, 0xf0, 0xb1, 0xe1, 0xb8, 0xd4, 0xac, 0xa4, 0xe5, 0x59, 0x9a, + 0x5c, 0xdb, 0x5b, 0xb3, 0xb0, 0xb3, 0x65, 0xb9, 0x15, 0x92, 0x44, 0xc6, 0x2c, 0x29, 0x0c, 0x1b, + 0xb3, 0x13, 0xc4, 0x20, 0xcb, 0x69, 0x7c, 0xdc, 0xa1, 0x63, 0x96, 0x37, 0xd1, 0xf7, 0xe0, 0x72, + 0xaf, 0x36, 0xe3, 0x6c, 0xad, 0x7f, 0x27, 0x41, 0xbe, 0x66, 0x1a, 0xee, 0xd7, 0xa2, 0x99, 0x3c, + 0xd5, 0x26, 0x83, 0xaa, 0xbd, 0x07, 0x85, 0x3d, 0xd5, 0x68, 0x3d, 0x33, 0x1b, 0x56, 0x7b, 0xd7, + 0x71, 0x2d, 0x13, 0x3b, 0x5c, 0xf7, 0x7d, 0x74, 0xae, 0xb3, 0x17, 0x30, 0xed, 0xd5, 0x29, 0x4e, + 0x65, 0xbd, 0x86, 0x42, 0xcd, 0xd4, 0x6c, 0xdc, 0xc6, 0x66, 0xac, 0xda, 0x7a, 0x1b, 0x32, 0x86, + 0x90, 0x4b, 0x35, 0x96, 0x94, 0x7d, 0x02, 0xaf, 0x53, 0x17, 0x66, 0x02, 0xef, 0x8e, 0xd3, 0x5c, + 0x92, 0x89, 0x03, 0x1f, 0x29, 0x7e, 0x7b, 0x91, 0x89, 0x03, 0x1f, 0x31, 0xf3, 0xf6, 0x19, 0x4c, + 0xad, 0xe1, 0x16, 0x76, 0x71, 0xfc, 0xb6, 0x7f, 0x07, 0xf2, 0x42, 0x74, 0x9c, 0x8d, 0xf4, 0x5b, + 0x12, 0x20, 0x2e, 0x97, 0xcc, 0xb8, 0x71, 0xb6, 0xd3, 0x02, 0x71, 0x33, 0xdc, 0xae, 0x6d, 0x32, 0x7f, 0x81, 0xf5, 0x52, 0x60, 0x24, 0xea, 0x32, 0xf8, 0x36, 0x38, 0x15, 0xb4, 0xc1, 0x9e, 0xdb, - 0x43, 0x1c, 0x9e, 0x7d, 0x98, 0x0c, 0x15, 0x2f, 0xde, 0xa6, 0x4c, 0xd1, 0x92, 0x25, 0x66, 0x93, - 0x41, 0xdf, 0x8e, 0x12, 0x8b, 0xff, 0x49, 0x80, 0x89, 0x52, 0x03, 0x2b, 0x56, 0xec, 0x7a, 0xf9, - 0x32, 0xa4, 0x35, 0xac, 0x68, 0xb4, 0xe2, 0x6c, 0xc0, 0xbf, 0x18, 0x90, 0x42, 0xfc, 0xda, 0xb9, - 0x9d, 0x86, 0x3a, 0x57, 0x73, 0x3d, 0x5e, 0x3e, 0xea, 0x3d, 0x26, 0xde, 0x21, 0xde, 0x05, 0x14, - 0x2c, 0x5f, 0x9c, 0x9d, 0xe2, 0x3f, 0x0b, 0x80, 0x24, 0xbc, 0x87, 0x2d, 0x27, 0xf6, 0xca, 0x2f, - 0x41, 0xd6, 0x51, 0xac, 0x3a, 0x76, 0x64, 0xe2, 0xd1, 0x9f, 0xa4, 0xfe, 0xc0, 0xf8, 0x08, 0x99, - 0x6b, 0xe0, 0x3d, 0x98, 0x0c, 0x95, 0x32, 0x4e, 0x15, 0xfc, 0xa5, 0x00, 0xd9, 0xaa, 0xaa, 0x18, - 0x71, 0xd6, 0xfd, 0x1d, 0xc8, 0xda, 0xaa, 0x62, 0xc8, 0xdb, 0xa6, 0xd5, 0x54, 0x1c, 0xda, 0xe9, - 0xf3, 0xa1, 0xba, 0x7b, 0x7e, 0xb7, 0xaa, 0x18, 0xf7, 0x68, 0x26, 0x09, 0x6c, 0xef, 0x3f, 0x7a, - 0x04, 0xd9, 0x5d, 0x7c, 0x28, 0x73, 0x7c, 0x46, 0x67, 0xca, 0xfc, 0xed, 0x57, 0x03, 0xfc, 0xbb, - 0x7b, 0x73, 0x2e, 0xac, 0x9b, 0x0b, 0xc0, 0xba, 0x39, 0xc2, 0x31, 0x57, 0x75, 0x2c, 0x6c, 0xd4, - 0x9d, 0x1d, 0x09, 0x76, 0xf1, 0xe1, 0x03, 0x26, 0x23, 0x38, 0xd4, 0x56, 0x52, 0xe9, 0xa4, 0x98, - 0x2a, 0xfe, 0x95, 0x00, 0x39, 0x56, 0xf1, 0x38, 0x87, 0xda, 0xeb, 0x90, 0xb2, 0xcc, 0x7d, 0x36, - 0xd4, 0xb2, 0xb7, 0x2f, 0x44, 0x88, 0x58, 0xc5, 0x87, 0xc1, 0x39, 0x8e, 0x66, 0x47, 0x8b, 0xc0, - 0xbd, 0x47, 0x99, 0x72, 0x27, 0x07, 0xe5, 0x06, 0xc6, 0x25, 0x11, 0x19, 0xd7, 0x60, 0x7c, 0x4b, - 0x71, 0xd4, 0x1d, 0xd9, 0xe2, 0x85, 0x24, 0xf3, 0x61, 0xf2, 0x7a, 0x4e, 0xca, 0x53, 0xb2, 0x5b, - 0x74, 0xbb, 0xf8, 0xd7, 0x6e, 0xaf, 0xb7, 0xf1, 0x6f, 0x64, 0xcb, 0xff, 0x8d, 0xc0, 0xc7, 0x93, - 0x5b, 0xff, 0xdf, 0xb4, 0x0e, 0xf0, 0x41, 0x02, 0xce, 0x95, 0x76, 0xb0, 0xba, 0x5b, 0x32, 0x0d, - 0x5b, 0xb7, 0x1d, 0xa2, 0xc1, 0x38, 0x7b, 0xc1, 0x05, 0xc8, 0xec, 0xeb, 0xce, 0x8e, 0xac, 0xe9, - 0xdb, 0xdb, 0xd4, 0xf2, 0xa5, 0xa5, 0x34, 0x21, 0x2c, 0xe9, 0xdb, 0xdb, 0xe8, 0x0e, 0xa4, 0x9a, - 0xa6, 0xc6, 0x9c, 0xec, 0xfc, 0xed, 0x99, 0x08, 0xf1, 0xb4, 0x68, 0x76, 0xbb, 0xb9, 0x66, 0x6a, - 0x58, 0xa2, 0x99, 0xd1, 0x45, 0x00, 0x95, 0x50, 0x5b, 0xa6, 0x6e, 0x38, 0x7c, 0x16, 0x0d, 0x50, - 0x50, 0x05, 0x32, 0x0e, 0xb6, 0x9a, 0xba, 0xa1, 0x38, 0xb8, 0x30, 0x4c, 0x95, 0x77, 0x39, 0xb2, - 0xe0, 0xad, 0x86, 0xae, 0x2a, 0x4b, 0xd8, 0x56, 0x2d, 0xbd, 0xe5, 0x98, 0x16, 0xd7, 0xa2, 0xcf, - 0xcc, 0x2d, 0xee, 0xfb, 0x29, 0x28, 0x74, 0x6b, 0x28, 0xce, 0x7e, 0xb2, 0x01, 0x23, 0x04, 0xa7, - 0x37, 0x1c, 0xde, 0x53, 0x6e, 0xf7, 0x52, 0x44, 0x44, 0x09, 0x28, 0xde, 0x6f, 0x38, 0xbc, 0xf0, - 0x5c, 0xce, 0xf4, 0x8f, 0x05, 0x18, 0x61, 0x09, 0xe8, 0x16, 0xa4, 0xf9, 0xc2, 0x84, 0x46, 0xcb, - 0x98, 0x5c, 0x3c, 0xfb, 0xfc, 0x68, 0x66, 0x94, 0xad, 0x35, 0x2c, 0x7d, 0xe2, 0xff, 0x95, 0x46, - 0x69, 0xbe, 0x65, 0x8d, 0xb4, 0x99, 0xed, 0x28, 0x96, 0x43, 0x17, 0x81, 0x12, 0x0c, 0x73, 0x50, - 0xc2, 0x2a, 0x3e, 0x44, 0x2b, 0x30, 0x62, 0x3b, 0x8a, 0xd3, 0xb6, 0x79, 0xab, 0x9d, 0xa8, 0xb0, - 0x55, 0xca, 0x29, 0x71, 0x09, 0xc4, 0x19, 0xd2, 0xb0, 0xa3, 0xe8, 0x0d, 0xda, 0x8c, 0x19, 0x89, - 0x3f, 0x15, 0xbf, 0x27, 0xc0, 0x08, 0xcb, 0x8a, 0xce, 0xc1, 0xa4, 0xb4, 0xb0, 0x7e, 0xbf, 0x2c, - 0x2f, 0xaf, 0x2f, 0x95, 0x6b, 0x65, 0x69, 0x6d, 0x79, 0x7d, 0xa1, 0x56, 0x16, 0x87, 0xd0, 0x59, - 0x40, 0x6e, 0x42, 0xe9, 0xe1, 0x7a, 0x75, 0xb9, 0x5a, 0x2b, 0xaf, 0xd7, 0x44, 0x81, 0xae, 0x51, - 0x50, 0x7a, 0x80, 0x9a, 0x40, 0x97, 0x61, 0xb6, 0x93, 0x2a, 0x57, 0x6b, 0x0b, 0xb5, 0xaa, 0x5c, - 0xae, 0xd6, 0x96, 0xd7, 0x16, 0x6a, 0xe5, 0x25, 0x31, 0xd9, 0x27, 0x17, 0x79, 0x89, 0x24, 0x95, - 0x4b, 0x35, 0x31, 0x55, 0x7c, 0x06, 0x67, 0x24, 0xac, 0x9a, 0xcd, 0x56, 0xdb, 0xc1, 0xa4, 0x94, - 0x76, 0x9c, 0xe3, 0xe5, 0x1c, 0x8c, 0x6a, 0xd6, 0xa1, 0x6c, 0xb5, 0x0d, 0x3e, 0x5a, 0x46, 0x34, - 0xeb, 0x50, 0x6a, 0x1b, 0xbc, 0x33, 0xfe, 0x77, 0x01, 0xce, 0x76, 0xbe, 0x3c, 0xce, 0xae, 0xf8, - 0x08, 0xb2, 0x8a, 0xa6, 0x61, 0x4d, 0xd6, 0x70, 0xc3, 0x51, 0xb8, 0xab, 0x72, 0x33, 0x20, 0x89, - 0x2f, 0xe0, 0xcd, 0x79, 0x0b, 0x78, 0x6b, 0x8f, 0x4b, 0x25, 0x5a, 0x90, 0x25, 0xc2, 0xe1, 0x9a, - 0x22, 0x2a, 0x84, 0x52, 0x8a, 0xff, 0x3f, 0x05, 0x63, 0x65, 0x43, 0xab, 0x1d, 0xc4, 0x3a, 0xbb, - 0x9c, 0x85, 0x11, 0xd5, 0x6c, 0x36, 0x75, 0xc7, 0x55, 0x13, 0x7b, 0x42, 0x5f, 0x0c, 0x38, 0x9a, - 0xc9, 0x01, 0x1c, 0x2d, 0xdf, 0xc5, 0x44, 0xdf, 0x84, 0x73, 0xc4, 0x82, 0x5a, 0x86, 0xd2, 0x90, - 0x99, 0x34, 0xd9, 0xb1, 0xf4, 0x7a, 0x1d, 0x5b, 0x7c, 0xb9, 0xf0, 0x7a, 0x44, 0x39, 0x97, 0x39, - 0x47, 0x89, 0x32, 0xd4, 0x58, 0x7e, 0xe9, 0x8c, 0x1e, 0x45, 0x46, 0x6f, 0x03, 0x90, 0xc9, 0x89, - 0x2e, 0x41, 0xda, 0xdc, 0x36, 0xf5, 0x5a, 0x83, 0x74, 0xcd, 0x11, 0x61, 0x20, 0xcf, 0x36, 0x9a, - 0x27, 0xd8, 0xe2, 0x69, 0x5b, 0xb7, 0xb0, 0x7c, 0xab, 0xa5, 0xd2, 0xc5, 0x80, 0xf4, 0x62, 0xfe, - 0xf9, 0xd1, 0x0c, 0x48, 0x8c, 0x7c, 0x6b, 0xa3, 0x44, 0xb0, 0x06, 0xfb, 0xdf, 0x52, 0xd1, 0x13, - 0xb8, 0x11, 0x58, 0xd3, 0x20, 0x73, 0x31, 0xaf, 0x96, 0xe2, 0xc8, 0x3b, 0x7a, 0x7d, 0x07, 0x5b, - 0xb2, 0xb7, 0xc4, 0x4c, 0xd7, 0x03, 0xd3, 0xd2, 0x65, 0x9f, 0xa1, 0xa4, 0x18, 0xac, 0xf4, 0x0b, - 0x4e, 0x85, 0x66, 0xf6, 0x74, 0x46, 0x94, 0xdf, 0x32, 0x75, 0xdb, 0x34, 0x0a, 0x19, 0xa6, 0x7c, - 0xf6, 0x84, 0x1e, 0x81, 0xa8, 0x1b, 0xf2, 0x76, 0x43, 0xaf, 0xef, 0x38, 0xf2, 0xbe, 0xa5, 0x3b, - 0xd8, 0x2e, 0x4c, 0xd0, 0x5a, 0x46, 0x75, 0xc6, 0x2a, 0x5f, 0xf2, 0xd5, 0x9e, 0x90, 0x9c, 0xbc, - 0xbe, 0x79, 0xdd, 0xb8, 0x47, 0xf9, 0x29, 0xd1, 0xf6, 0xa6, 0xec, 0x51, 0x31, 0x5d, 0xfc, 0x43, - 0x01, 0xf2, 0x6e, 0x4f, 0x8a, 0xb3, 0xd3, 0x5f, 0x07, 0xd1, 0x34, 0xb0, 0xdc, 0xda, 0x51, 0x6c, - 0xcc, 0x55, 0xc4, 0xe7, 0x95, 0xbc, 0x69, 0xe0, 0x0d, 0x42, 0x66, 0x9a, 0x40, 0x1b, 0x30, 0x61, - 0x3b, 0x4a, 0x5d, 0x37, 0xea, 0x01, 0xcd, 0x0d, 0x0f, 0xee, 0xcf, 0x8b, 0x9c, 0xdb, 0xa3, 0x87, - 0x9c, 0x91, 0x5f, 0x08, 0x30, 0xb1, 0xa0, 0x35, 0x75, 0xa3, 0xda, 0x6a, 0xe8, 0xb1, 0x2e, 0x1f, - 0x5c, 0x86, 0x8c, 0x4d, 0x64, 0xfa, 0x16, 0xdd, 0x87, 0x7e, 0x69, 0x9a, 0x42, 0x4c, 0xfb, 0x03, - 0x18, 0xc7, 0x07, 0x2d, 0xdd, 0x52, 0x1c, 0xdd, 0x34, 0x18, 0x56, 0x49, 0x0d, 0x5e, 0xb7, 0xbc, - 0xcf, 0xeb, 0xe3, 0x15, 0x5e, 0xb3, 0x77, 0x01, 0x05, 0x2b, 0x16, 0x27, 0x68, 0x91, 0x61, 0x92, - 0x8a, 0xde, 0x34, 0xec, 0x98, 0xb5, 0xc6, 0x4d, 0xee, 0xd7, 0x60, 0x2a, 0xfc, 0x82, 0x38, 0x4b, - 0xff, 0x0d, 0xde, 0xe2, 0x6b, 0xd8, 0xaa, 0x7f, 0x06, 0x0b, 0x28, 0xae, 0xde, 0xb9, 0xf8, 0x38, - 0x4b, 0xfe, 0x5d, 0x01, 0xce, 0x53, 0xd9, 0x74, 0xab, 0x65, 0x1b, 0x5b, 0x0f, 0xb0, 0x62, 0xc7, - 0x0a, 0x9b, 0x5f, 0x82, 0x11, 0x06, 0x7f, 0x69, 0x8f, 0x1d, 0x5e, 0xcc, 0x12, 0x67, 0xa5, 0xea, - 0x98, 0x16, 0x71, 0x56, 0x78, 0x12, 0xaf, 0xa7, 0x02, 0xd3, 0x51, 0x65, 0x89, 0x79, 0x7d, 0x60, - 0x82, 0xfb, 0x8c, 0xa4, 0x8b, 0x97, 0x76, 0x88, 0xb3, 0x84, 0xca, 0x90, 0x55, 0xe9, 0x3f, 0xd9, - 0x39, 0x6c, 0x61, 0x2a, 0x3f, 0xdf, 0xcf, 0xdd, 0x64, 0x6c, 0xb5, 0xc3, 0x16, 0x26, 0x3e, 0xab, - 0xfb, 0x9f, 0xa8, 0x2b, 0x50, 0xd5, 0xbe, 0x0e, 0x2b, 0x1d, 0x5f, 0x34, 0xaf, 0xeb, 0xf3, 0x85, - 0x34, 0xf1, 0x3f, 0x92, 0x5c, 0x15, 0xec, 0x4d, 0x9c, 0x29, 0x56, 0x17, 0xe5, 0xbd, 0xd0, 0xae, - 0x57, 0xb0, 0xfa, 0x89, 0x13, 0x54, 0x3f, 0xb0, 0xdc, 0xee, 0x53, 0xd1, 0xbb, 0x10, 0x58, 0x50, - 0x97, 0x59, 0xcd, 0x5c, 0x08, 0x74, 0x12, 0xa5, 0x4c, 0xf8, 0x52, 0x18, 0xdd, 0x46, 0x25, 0x48, - 0xe3, 0x83, 0x96, 0xac, 0x61, 0x5b, 0xe5, 0x66, 0xad, 0xd8, 0x6b, 0x7b, 0xae, 0x0b, 0x14, 0x8c, - 0xe2, 0x83, 0x16, 0x21, 0xa2, 0x4d, 0x32, 0xc3, 0xb9, 0x3e, 0x02, 0x2d, 0xb6, 0x7d, 0x3c, 0xc6, - 0xf0, 0xfb, 0x0b, 0x17, 0x37, 0xee, 0xb9, 0x07, 0x4c, 0x04, 0x6f, 0xbb, 0x0f, 0x05, 0xb8, 0x10, - 0xd9, 0x76, 0x71, 0x4e, 0x76, 0x6f, 0x43, 0x8a, 0xaa, 0x20, 0x71, 0x42, 0x15, 0x50, 0xae, 0xe2, - 0x8f, 0xdc, 0x51, 0x2f, 0xe1, 0x86, 0x49, 0xd4, 0xfb, 0x19, 0x2c, 0x96, 0x8d, 0xba, 0xcd, 0x9e, - 0x38, 0x71, 0xb3, 0xbb, 0xac, 0x1d, 0x66, 0xa1, 0xa3, 0xb0, 0x71, 0x9a, 0x85, 0x7f, 0x27, 0xc0, - 0x64, 0x05, 0x2b, 0x96, 0xb3, 0x85, 0x15, 0x27, 0x66, 0x1f, 0xf7, 0x75, 0x48, 0x1a, 0xe6, 0xfe, - 0x49, 0xd6, 0x0b, 0x49, 0x7e, 0x7f, 0xda, 0x0a, 0x97, 0x2b, 0xce, 0x5a, 0xff, 0x56, 0x02, 0x32, - 0xf7, 0x4b, 0x71, 0xd6, 0xf5, 0x6d, 0xbe, 0x2e, 0xcd, 0x86, 0x7a, 0x54, 0xb7, 0xf4, 0xde, 0x37, - 0x77, 0xbf, 0xb4, 0x8a, 0x0f, 0xdd, 0x6e, 0x49, 0xb8, 0xd0, 0x02, 0x64, 0x9c, 0x1d, 0x0b, 0xdb, - 0x3b, 0x66, 0x43, 0x3b, 0x89, 0xcf, 0xe2, 0x73, 0x4d, 0xef, 0xc2, 0x30, 0x95, 0xeb, 0xc6, 0x46, - 0x08, 0x11, 0xb1, 0x11, 0xe4, 0x35, 0x9e, 0xdb, 0x97, 0x38, 0xc9, 0x6b, 0x5c, 0x02, 0x6b, 0x1c, - 0xcf, 0x37, 0x1a, 0x16, 0x47, 0x8a, 0x8f, 0x00, 0x48, 0xd5, 0xe2, 0x6c, 0x9e, 0x7f, 0x95, 0x84, - 0xfc, 0x46, 0xdb, 0xde, 0x89, 0xb9, 0x3f, 0x96, 0x00, 0x5a, 0x6d, 0x9b, 0xc2, 0x86, 0x03, 0x83, - 0xd7, 0xff, 0x98, 0xe0, 0x0b, 0x57, 0x01, 0x8c, 0xaf, 0x76, 0x60, 0xa0, 0x0a, 0x17, 0x82, 0x65, - 0x3f, 0x82, 0xe3, 0xa5, 0x7e, 0x00, 0xb3, 0x76, 0x60, 0xac, 0x61, 0x0f, 0x59, 0x32, 0x49, 0x98, - 0x48, 0x7a, 0x1b, 0x46, 0xc9, 0x83, 0xec, 0x98, 0x27, 0x69, 0xf2, 0x11, 0xc2, 0x53, 0x33, 0xd1, - 0x5d, 0xc8, 0x30, 0x6e, 0x32, 0x71, 0x8d, 0xd0, 0x89, 0x2b, 0xaa, 0x2e, 0x5c, 0x8d, 0x74, 0xca, - 0x4a, 0x53, 0x56, 0x32, 0x4d, 0x4d, 0xc1, 0xf0, 0xb6, 0x69, 0xa9, 0x98, 0x86, 0x65, 0xa4, 0x25, - 0xf6, 0x10, 0x6c, 0xd5, 0x95, 0x54, 0x3a, 0x2d, 0x66, 0x56, 0x52, 0xe9, 0x8c, 0x08, 0xc5, 0xef, - 0x09, 0x30, 0xee, 0x35, 0x47, 0x9c, 0xb6, 0xbc, 0x14, 0xd2, 0xe5, 0xc9, 0x1b, 0x84, 0xa8, 0xb1, - 0xf8, 0xdb, 0xd4, 0xb1, 0x51, 0xcd, 0x3d, 0xda, 0x3e, 0x71, 0xf6, 0x97, 0xbb, 0x2c, 0x4a, 0x27, - 0x71, 0xd2, 0x36, 0xa6, 0x01, 0x3b, 0xb7, 0x60, 0x4a, 0x6f, 0x12, 0x2b, 0xaf, 0x3b, 0x8d, 0x43, - 0x8e, 0xca, 0x1c, 0xec, 0x6e, 0xfc, 0x4e, 0xfa, 0x69, 0x25, 0x37, 0x89, 0x1b, 0x3e, 0xb6, 0x91, - 0xe3, 0xd7, 0x27, 0x4e, 0x85, 0x2f, 0xc3, 0x98, 0xc5, 0x44, 0x13, 0xef, 0xe4, 0x84, 0x3a, 0xcf, - 0x79, 0xac, 0x44, 0xed, 0x3f, 0x4c, 0xc0, 0xf8, 0xa3, 0x36, 0xb6, 0x0e, 0x3f, 0x4f, 0x4a, 0xbf, - 0x0a, 0xe3, 0xfb, 0x8a, 0xee, 0xc8, 0xdb, 0xa6, 0x25, 0xb7, 0x5b, 0x9a, 0xe2, 0xb8, 0xa1, 0x22, - 0x63, 0x84, 0x7c, 0xcf, 0xb4, 0x36, 0x29, 0x11, 0x61, 0x40, 0xbb, 0x86, 0xb9, 0x6f, 0xc8, 0x84, - 0x4c, 0xd1, 0xf0, 0x81, 0xc1, 0x57, 0x98, 0x17, 0xdf, 0xf8, 0x83, 0xa3, 0x99, 0x3b, 0x03, 0x05, - 0x83, 0xd1, 0x70, 0xb6, 0x76, 0x5b, 0xd7, 0xe6, 0x36, 0x37, 0x97, 0x97, 0x24, 0x91, 0x8a, 0x7c, - 0xc2, 0x24, 0xd6, 0x0e, 0x0c, 0x77, 0x16, 0xff, 0x2f, 0x09, 0x10, 0x7d, 0x4d, 0xc5, 0xd9, 0x9c, - 0x65, 0xc8, 0x3e, 0x6d, 0x63, 0x4b, 0x3f, 0x45, 0x63, 0x02, 0x67, 0x24, 0x86, 0xe8, 0x3d, 0xc8, - 0x85, 0xf4, 0x90, 0xfc, 0x74, 0x7a, 0xc8, 0xee, 0xfb, 0x2a, 0x40, 0x37, 0x61, 0xc2, 0x39, 0x30, - 0x64, 0x16, 0xec, 0xc7, 0xc2, 0x45, 0xdc, 0xd8, 0x86, 0x71, 0x87, 0xe8, 0x83, 0xd0, 0x69, 0xa8, - 0x88, 0x5d, 0xfc, 0x7f, 0x02, 0x20, 0xaa, 0xa8, 0x65, 0xb6, 0x11, 0xf0, 0x79, 0xe9, 0x55, 0xd7, - 0x41, 0xa4, 0x41, 0x93, 0xb2, 0xbe, 0x2d, 0x37, 0x75, 0xdb, 0xd6, 0x8d, 0x3a, 0xef, 0x56, 0x79, - 0x4a, 0x5f, 0xde, 0x5e, 0x63, 0x54, 0xde, 0xe0, 0xff, 0x08, 0x26, 0x43, 0xd5, 0x88, 0xb3, 0xc9, - 0x2f, 0x41, 0x6e, 0xdb, 0x6c, 0x1b, 0x9a, 0xcc, 0x36, 0x4b, 0xf8, 0xea, 0x61, 0x96, 0xd2, 0xd8, - 0xfb, 0x8a, 0x7f, 0x9e, 0x80, 0x29, 0x09, 0xdb, 0x66, 0x63, 0x0f, 0xc7, 0xaf, 0xc8, 0x0a, 0xf0, - 0x6d, 0x1a, 0xf9, 0x54, 0xfa, 0xcc, 0x30, 0x66, 0x36, 0xfd, 0x85, 0x17, 0xe2, 0x2f, 0xf7, 0xef, - 0xb7, 0xdd, 0x4b, 0xef, 0x7c, 0x09, 0x2f, 0x15, 0x5a, 0xc2, 0x33, 0x61, 0x5c, 0xaf, 0x1b, 0x26, - 0xb1, 0x6f, 0x36, 0x7e, 0x6a, 0xb4, 0x9b, 0x2e, 0xbe, 0x99, 0xeb, 0x57, 0xc8, 0x65, 0xc6, 0x52, - 0xc5, 0x4f, 0xd7, 0xdb, 0x4d, 0xea, 0x65, 0x2f, 0x9e, 0x25, 0xe5, 0x7d, 0x7e, 0x34, 0x93, 0x0f, - 0xa5, 0xd9, 0x52, 0x5e, 0xf7, 0x9e, 0x89, 0x74, 0xde, 0xe4, 0x5f, 0x87, 0x33, 0x1d, 0x2a, 0x8f, - 0xd3, 0x1f, 0xfa, 0xbf, 0x49, 0x38, 0x1f, 0x16, 0x1f, 0x37, 0x6a, 0xf9, 0xbc, 0x37, 0x6b, 0x05, - 0xc6, 0x9a, 0xba, 0x71, 0xba, 0x45, 0xcb, 0x5c, 0x53, 0x37, 0xfc, 0xb5, 0xdf, 0x88, 0x0e, 0x32, - 0xf2, 0x77, 0xd0, 0x41, 0x14, 0x98, 0x8e, 0x6a, 0xc1, 0x38, 0x7b, 0xc9, 0xfb, 0x02, 0xe4, 0xe2, - 0x5e, 0x87, 0x3b, 0x5d, 0x98, 0x1b, 0xaf, 0x73, 0x0d, 0xc6, 0x3e, 0x83, 0x85, 0xbb, 0x1f, 0x0a, - 0x80, 0x6a, 0x56, 0xdb, 0x20, 0x80, 0xf8, 0x81, 0x59, 0x8f, 0xb3, 0xb2, 0x53, 0x30, 0xac, 0x1b, - 0x1a, 0x3e, 0xa0, 0x95, 0x4d, 0x49, 0xec, 0x21, 0xb4, 0x03, 0x99, 0x1c, 0x68, 0x07, 0xd2, 0x8f, - 0x75, 0x09, 0x15, 0x34, 0x4e, 0x2d, 0xfc, 0xb7, 0x04, 0x4c, 0xf2, 0xea, 0xc4, 0xbe, 0x70, 0xf9, - 0x1a, 0x0c, 0x37, 0x88, 0xcc, 0x3e, 0x6d, 0x4e, 0xdf, 0xe9, 0xb6, 0x39, 0xcd, 0x8c, 0xbe, 0x04, - 0xd0, 0xb2, 0xf0, 0x9e, 0xcc, 0x58, 0x93, 0x03, 0xb1, 0x66, 0x08, 0x07, 0x25, 0xa0, 0xaf, 0xc2, - 0x38, 0x19, 0xe1, 0x2d, 0xcb, 0x6c, 0x99, 0x36, 0x71, 0x68, 0xec, 0xc1, 0x50, 0xd1, 0xc4, 0xf3, - 0xa3, 0x99, 0xb1, 0x35, 0xdd, 0xd8, 0xe0, 0x8c, 0xb5, 0xaa, 0x44, 0x4c, 0x85, 0xf7, 0xe8, 0x0e, - 0xc0, 0xdf, 0x13, 0x60, 0xea, 0x33, 0x5b, 0xea, 0xfd, 0xfb, 0xd0, 0x98, 0x37, 0xf3, 0x88, 0xf4, - 0x71, 0xd9, 0xd8, 0x36, 0xe3, 0x5f, 0x80, 0x7f, 0x5f, 0x80, 0x89, 0x80, 0xf8, 0x38, 0x3d, 0x99, - 0x53, 0xe9, 0xac, 0xf8, 0x35, 0xe2, 0xdb, 0x04, 0xbb, 0x7d, 0x9c, 0x83, 0xea, 0x7f, 0x25, 0xe0, - 0x6c, 0x89, 0xed, 0x4d, 0xbb, 0x81, 0x1b, 0x71, 0xf6, 0x92, 0x02, 0x8c, 0xee, 0x61, 0xcb, 0xd6, - 0x4d, 0x36, 0xc3, 0x8e, 0x49, 0xee, 0x23, 0x9a, 0x86, 0xb4, 0x6d, 0x28, 0x2d, 0x7b, 0xc7, 0x74, - 0x77, 0xee, 0xbc, 0x67, 0x2f, 0xc8, 0x64, 0xf8, 0xf4, 0x41, 0x26, 0x23, 0xfd, 0x83, 0x4c, 0x46, - 0x3f, 0x75, 0x90, 0x09, 0xdf, 0x26, 0xfb, 0xa9, 0x00, 0xe7, 0xba, 0xf4, 0x17, 0x67, 0x9f, 0xf9, - 0x16, 0x64, 0x55, 0x2e, 0x98, 0x58, 0x63, 0xb6, 0x13, 0xb8, 0x4c, 0xb2, 0x9d, 0x12, 0xac, 0x3c, - 0x3f, 0x9a, 0x01, 0xb7, 0xa8, 0xcb, 0x4b, 0x5c, 0x45, 0xe4, 0xbf, 0x56, 0xfc, 0xfd, 0x1c, 0x8c, - 0x97, 0x0f, 0xd8, 0x3a, 0x77, 0x95, 0xf9, 0x03, 0xe8, 0x1e, 0xa4, 0x5b, 0x96, 0xb9, 0xa7, 0xbb, - 0xd5, 0xc8, 0x87, 0x62, 0x0b, 0xdc, 0x6a, 0x74, 0x70, 0x6d, 0x70, 0x0e, 0xc9, 0xe3, 0x45, 0x35, - 0xc8, 0x3c, 0x30, 0x55, 0xa5, 0x71, 0x4f, 0x6f, 0xb8, 0xfd, 0xff, 0xd5, 0xe3, 0x05, 0xcd, 0x79, - 0x3c, 0x1b, 0x8a, 0xb3, 0xe3, 0x36, 0x85, 0x47, 0x44, 0xcb, 0x90, 0xae, 0x38, 0x4e, 0x8b, 0x24, - 0x72, 0x6b, 0x72, 0x6d, 0x00, 0xa1, 0x84, 0xc5, 0x0d, 0x57, 0x75, 0xd9, 0x51, 0x0d, 0x26, 0xee, - 0x9b, 0x66, 0xbd, 0x81, 0x4b, 0x0d, 0xb3, 0xad, 0x95, 0x4c, 0x63, 0x5b, 0xaf, 0x73, 0x7b, 0x7c, - 0x75, 0x00, 0x99, 0xf7, 0x4b, 0x55, 0xa9, 0x5b, 0x00, 0x5a, 0x80, 0x74, 0xf5, 0x0e, 0x17, 0xc6, - 0x1c, 0xb8, 0x2b, 0x03, 0x08, 0xab, 0xde, 0x91, 0x3c, 0x36, 0xb4, 0x02, 0xd9, 0x85, 0x67, 0x6d, - 0x0b, 0x73, 0x29, 0x23, 0x3d, 0x03, 0x1b, 0x3a, 0xa5, 0x50, 0x2e, 0x29, 0xc8, 0x8c, 0xaa, 0x90, - 0x7f, 0x62, 0x5a, 0xbb, 0x0d, 0x53, 0x71, 0x6b, 0x38, 0x4a, 0xc5, 0x7d, 0x61, 0x00, 0x71, 0x2e, - 0xa3, 0xd4, 0x21, 0x02, 0x7d, 0x1d, 0xc6, 0x49, 0x63, 0xd4, 0x94, 0xad, 0x86, 0x5b, 0xc8, 0x34, - 0x95, 0xfa, 0xf2, 0x00, 0x52, 0x3d, 0x4e, 0x77, 0xa3, 0xa5, 0x43, 0xd4, 0xf4, 0x57, 0x61, 0x2c, - 0xd4, 0x09, 0x10, 0x82, 0x54, 0x8b, 0xb4, 0xb7, 0x40, 0x03, 0x90, 0xe8, 0x7f, 0xf4, 0x0a, 0x8c, - 0x1a, 0xa6, 0x86, 0xdd, 0x11, 0x32, 0xb6, 0x38, 0xf5, 0xfc, 0x68, 0x66, 0x64, 0xdd, 0xd4, 0x98, - 0xbb, 0xc2, 0xff, 0x49, 0x23, 0x24, 0x93, 0xeb, 0xac, 0x4c, 0x5f, 0x85, 0x14, 0x69, 0x7d, 0x62, - 0xa4, 0xb6, 0x14, 0x1b, 0x6f, 0x5a, 0x3a, 0x97, 0xe9, 0x3e, 0xf2, 0x7c, 0xbf, 0x14, 0x20, 0x51, - 0xbd, 0x43, 0x1c, 0xf5, 0xad, 0xb6, 0xba, 0x8b, 0x1d, 0x9e, 0x8b, 0x3f, 0x51, 0x07, 0xde, 0xc2, - 0xdb, 0x3a, 0xf3, 0xa1, 0x32, 0x12, 0x7f, 0x42, 0x2f, 0x02, 0x28, 0xaa, 0x8a, 0x6d, 0x5b, 0x76, - 0x0f, 0xee, 0x65, 0xa4, 0x0c, 0xa3, 0xac, 0xe2, 0x43, 0xc2, 0x66, 0x63, 0xd5, 0xc2, 0x8e, 0x1b, - 0x49, 0xc5, 0x9e, 0x08, 0x9b, 0x83, 0x9b, 0x2d, 0xd9, 0x31, 0x77, 0xb1, 0x41, 0xfb, 0x4c, 0x86, - 0x18, 0x9f, 0x66, 0xab, 0x46, 0x08, 0xc4, 0x6e, 0x62, 0x43, 0xf3, 0x8d, 0x5c, 0x46, 0xf2, 0x9e, - 0x89, 0x48, 0x0b, 0xd7, 0x75, 0x7e, 0xf6, 0x2c, 0x23, 0xf1, 0x27, 0xa2, 0x31, 0xa5, 0xed, 0xec, - 0xd0, 0x56, 0xc9, 0x48, 0xf4, 0x3f, 0xaf, 0xda, 0x7f, 0x10, 0x20, 0x79, 0xbf, 0x54, 0x3d, 0x71, - 0xdd, 0x5c, 0x89, 0x49, 0x5f, 0x22, 0x0d, 0x60, 0xd4, 0x1b, 0x0d, 0xdd, 0xa8, 0x13, 0x97, 0xe6, - 0x5b, 0x58, 0x75, 0x6b, 0x96, 0xe7, 0xe4, 0x0d, 0x46, 0x45, 0xb3, 0x90, 0x55, 0x2d, 0xac, 0x61, - 0xc3, 0xd1, 0x95, 0x86, 0xcd, 0xab, 0x18, 0x24, 0xf1, 0xc2, 0x7d, 0x47, 0x80, 0x61, 0xda, 0x79, - 0xd1, 0x0b, 0x90, 0x51, 0x4d, 0xc3, 0x51, 0x74, 0x83, 0x5b, 0xa1, 0x8c, 0xe4, 0x13, 0x7a, 0x16, - 0xf2, 0x12, 0xe4, 0x14, 0x55, 0x35, 0xdb, 0x86, 0x23, 0x1b, 0x4a, 0x13, 0xf3, 0xc2, 0x66, 0x39, - 0x6d, 0x5d, 0x69, 0x62, 0x34, 0x03, 0xee, 0xa3, 0x77, 0x7c, 0x32, 0x23, 0x01, 0x27, 0xad, 0xe2, - 0x43, 0x5e, 0x92, 0x9f, 0x0a, 0x90, 0x76, 0x3b, 0x3d, 0x29, 0x4c, 0x1d, 0x1b, 0xd8, 0x52, 0x1c, - 0xd3, 0x2b, 0x8c, 0x47, 0xe8, 0x9c, 0xf1, 0x32, 0xfe, 0x8c, 0x37, 0x05, 0xc3, 0x0e, 0xe9, 0xd7, - 0xbc, 0x1c, 0xec, 0x81, 0xae, 0x4b, 0x37, 0x94, 0x3a, 0x5b, 0x8a, 0xcb, 0x48, 0xec, 0x81, 0x54, - 0x89, 0x07, 0xe1, 0x32, 0xed, 0xf0, 0x27, 0x52, 0x5e, 0x16, 0x24, 0xba, 0x85, 0xeb, 0xba, 0x41, - 0x3b, 0x40, 0x52, 0x02, 0x4a, 0x5a, 0x24, 0x14, 0x74, 0x01, 0x32, 0x2c, 0x03, 0x36, 0x34, 0xda, - 0x0b, 0x92, 0x52, 0x9a, 0x12, 0xca, 0xee, 0xf9, 0xb0, 0xe9, 0x5d, 0xc8, 0x78, 0x63, 0x8c, 0x34, - 0x64, 0xdb, 0xf6, 0x94, 0x4a, 0xff, 0xa3, 0x57, 0x61, 0xea, 0x69, 0x5b, 0x69, 0xe8, 0xdb, 0x74, - 0x95, 0x8d, 0x64, 0x63, 0xfa, 0x63, 0xf5, 0x41, 0x5e, 0x1a, 0x95, 0x40, 0xd5, 0xe8, 0x0e, 0xc9, - 0xa4, 0x3f, 0x24, 0x83, 0xdb, 0x26, 0xc5, 0x8f, 0x04, 0x98, 0x60, 0x21, 0x43, 0x2c, 0x94, 0x35, - 0x3e, 0x07, 0xe3, 0x2d, 0xc8, 0x68, 0x8a, 0xa3, 0xb0, 0x23, 0xa2, 0x89, 0xbe, 0x47, 0x44, 0xbd, - 0x03, 0x0a, 0x8a, 0xa3, 0xd0, 0x63, 0xa2, 0x08, 0x52, 0xe4, 0x3f, 0x3b, 0x53, 0x2b, 0xd1, 0xff, - 0x7e, 0x10, 0x46, 0xb0, 0xb8, 0x71, 0x3a, 0x5c, 0xf3, 0x70, 0x86, 0x68, 0xbf, 0x6c, 0xa8, 0xd6, - 0x61, 0xcb, 0xd1, 0x4d, 0xe3, 0x21, 0xfd, 0xb5, 0x91, 0x18, 0xd8, 0xc4, 0xa2, 0x7b, 0x57, 0xbc, - 0x2c, 0x3f, 0x19, 0x81, 0xb1, 0xf2, 0x41, 0xcb, 0xb4, 0x62, 0x5d, 0xd4, 0x5a, 0x84, 0x51, 0x8e, - 0xf8, 0xfb, 0x6c, 0x2b, 0x77, 0xd8, 0x6a, 0x77, 0xc7, 0x96, 0x33, 0xa2, 0x45, 0x00, 0x16, 0x74, - 0x4a, 0xe3, 0x8e, 0x92, 0x27, 0xd8, 0x5c, 0xa3, 0x6c, 0x84, 0x8a, 0xd6, 0x21, 0xdb, 0xdc, 0x53, - 0x55, 0x79, 0x5b, 0x6f, 0x38, 0x3c, 0x6a, 0x2f, 0x3a, 0xe4, 0x7c, 0xed, 0x71, 0xa9, 0x74, 0x8f, - 0x66, 0x62, 0x01, 0x74, 0xfe, 0xb3, 0x04, 0x44, 0x02, 0xfb, 0x8f, 0x5e, 0x06, 0x7e, 0x74, 0x47, - 0xb6, 0xdd, 0x53, 0x7a, 0x8b, 0x63, 0xcf, 0x8f, 0x66, 0x32, 0x12, 0xa5, 0x56, 0xab, 0x35, 0x29, - 0xc3, 0x32, 0x54, 0x6d, 0x07, 0xbd, 0x04, 0x63, 0x66, 0x53, 0x77, 0x64, 0xd7, 0x07, 0xe2, 0x6e, - 0x63, 0x8e, 0x10, 0x5d, 0x1f, 0x09, 0xd5, 0xe0, 0x1a, 0x36, 0xe8, 0x28, 0x20, 0xf5, 0x94, 0xb7, - 0xd8, 0x5a, 0xa4, 0xc3, 0xc6, 0xbb, 0x6c, 0xb6, 0x1c, 0xbd, 0xa9, 0x3f, 0xa3, 0x1b, 0xdb, 0x7c, - 0x6f, 0xe9, 0x25, 0x96, 0x9d, 0xd4, 0x6f, 0x91, 0x2e, 0x52, 0xf2, 0xbc, 0x0f, 0x03, 0x59, 0xd1, - 0x77, 0x04, 0x38, 0xcb, 0x15, 0x29, 0x6f, 0xd1, 0x98, 0x79, 0xa5, 0xa1, 0x3b, 0x87, 0xf2, 0xee, - 0x5e, 0x21, 0x4d, 0x9d, 0xd3, 0x2f, 0x46, 0x36, 0x48, 0xa0, 0x1f, 0xcc, 0xb9, 0xcd, 0x72, 0xf8, - 0x80, 0x33, 0xaf, 0xee, 0x95, 0x0d, 0xc7, 0x3a, 0x5c, 0x3c, 0xf7, 0xfc, 0x68, 0x66, 0xb2, 0x3b, - 0xf5, 0xb1, 0x34, 0x69, 0x77, 0xb3, 0xa0, 0x0a, 0x00, 0xf6, 0x7a, 0x23, 0x0d, 0x0f, 0x8c, 0x76, - 0x2f, 0x22, 0xbb, 0xad, 0x14, 0xe0, 0x45, 0xd7, 0x41, 0xe4, 0xa7, 0x66, 0xb6, 0xf5, 0x06, 0x96, - 0x6d, 0xfd, 0x19, 0x2e, 0x00, 0xb5, 0x41, 0x79, 0x46, 0x27, 0x22, 0xaa, 0xfa, 0x33, 0x3c, 0xfd, - 0x2d, 0x28, 0xf4, 0x2a, 0x7d, 0x70, 0x20, 0x64, 0xd8, 0x26, 0xee, 0x9b, 0xe1, 0x15, 0x99, 0x01, - 0xba, 0xaa, 0xbb, 0x2a, 0x93, 0x78, 0xd3, 0x35, 0x41, 0x3f, 0x4a, 0xc0, 0xd8, 0x62, 0xbb, 0xb1, - 0xfb, 0xb0, 0x55, 0x6d, 0x37, 0x9b, 0x8a, 0x75, 0x48, 0x4c, 0x25, 0x33, 0x1d, 0xa4, 0x98, 0x02, - 0x33, 0x95, 0xd4, 0x36, 0xe8, 0xcf, 0x30, 0x99, 0xcc, 0x82, 0xe7, 0xc4, 0xd9, 0x99, 0x00, 0x5a, - 0x93, 0xc0, 0xe1, 0x6f, 0x73, 0xdf, 0x46, 0x6f, 0x42, 0x21, 0x90, 0x91, 0x2e, 0x9f, 0xc8, 0xd8, - 0x70, 0x2c, 0x1d, 0xb3, 0xe5, 0xc0, 0xa4, 0x14, 0x08, 0xbd, 0x59, 0x26, 0xc9, 0x65, 0x96, 0x8a, - 0x6a, 0x90, 0x23, 0x19, 0x0f, 0x65, 0x3a, 0xd9, 0xb8, 0x8b, 0xb6, 0xb7, 0x22, 0x2a, 0x17, 0x2a, - 0xf7, 0x1c, 0xd5, 0x52, 0x89, 0xf2, 0xd0, 0xbf, 0x52, 0x16, 0xfb, 0x94, 0xe9, 0x77, 0x40, 0xec, - 0xcc, 0x10, 0xd4, 0x68, 0x8a, 0x69, 0x74, 0x2a, 0xa8, 0xd1, 0x64, 0x40, 0x5b, 0x2b, 0xa9, 0x74, - 0x4a, 0x1c, 0x2e, 0xfe, 0x2a, 0x09, 0x79, 0xb7, 0xb3, 0xc5, 0x89, 0x66, 0x16, 0x61, 0x98, 0x74, - 0x0d, 0x37, 0x50, 0xe4, 0x6a, 0x9f, 0x3e, 0xce, 0xe3, 0xcf, 0x49, 0x97, 0x71, 0xf1, 0x30, 0x65, - 0x8d, 0xc3, 0xec, 0x4c, 0xff, 0xe3, 0x04, 0xa4, 0x28, 0x80, 0xb8, 0x05, 0x29, 0x3a, 0x75, 0x08, - 0x83, 0x4c, 0x1d, 0x34, 0xab, 0x37, 0xd9, 0x25, 0x02, 0xfe, 0x27, 0x71, 0xe6, 0x76, 0x94, 0xd7, - 0x6f, 0xdd, 0xa6, 0x26, 0x27, 0x27, 0xf1, 0x27, 0xb4, 0x48, 0x23, 0x98, 0x4c, 0xcb, 0xc1, 0x1a, - 0x77, 0xdc, 0x67, 0x8f, 0x6b, 0x5f, 0x77, 0x9a, 0x72, 0xf9, 0xd0, 0x79, 0x48, 0x12, 0x5b, 0x36, - 0xca, 0xa2, 0x1b, 0x9e, 0x1f, 0xcd, 0x24, 0x89, 0x15, 0x23, 0x34, 0x34, 0x0f, 0xd9, 0xb0, 0xe1, - 0x10, 0xae, 0x67, 0x98, 0x79, 0x0c, 0x0c, 0x7a, 0x68, 0x78, 0x03, 0x8c, 0x81, 0x56, 0xde, 0xc6, - 0xdf, 0x1e, 0x86, 0xb1, 0xe5, 0x66, 0xdc, 0x13, 0xcb, 0x42, 0xb8, 0x85, 0xa3, 0xd0, 0x4e, 0xe8, - 0xa5, 0x11, 0x0d, 0x1c, 0x9a, 0xd3, 0x93, 0x27, 0x9b, 0xd3, 0x97, 0x89, 0x0b, 0xcc, 0x2f, 0x7e, - 0x48, 0xf6, 0x00, 0x36, 0xe1, 0xf7, 0x53, 0x2f, 0x46, 0x22, 0x3c, 0xfe, 0x89, 0x0c, 0x1a, 0xa1, - 0xf2, 0x0e, 0xf5, 0xb4, 0x59, 0x2f, 0x1b, 0x19, 0xbc, 0x97, 0x8d, 0x62, 0x43, 0xa3, 0x53, 0x5b, - 0xd8, 0xae, 0x8e, 0x9e, 0xde, 0xae, 0x4e, 0x3f, 0xe3, 0x9d, 0xf5, 0x2d, 0x48, 0x6a, 0xba, 0xdb, - 0x38, 0x83, 0x4f, 0xd8, 0x84, 0xe9, 0x98, 0x5e, 0x9b, 0x0a, 0xf6, 0xda, 0xe0, 0x02, 0xc7, 0xf4, - 0x43, 0x00, 0x5f, 0x43, 0x68, 0x16, 0x46, 0xcc, 0x86, 0xe6, 0x1e, 0x4c, 0x19, 0x5b, 0xcc, 0x3c, - 0x3f, 0x9a, 0x19, 0x7e, 0xd8, 0xd0, 0x96, 0x97, 0xa4, 0x61, 0xb3, 0xa1, 0x2d, 0x6b, 0xf4, 0xee, - 0x0d, 0xbc, 0x2f, 0x7b, 0x01, 0x6b, 0x39, 0x69, 0xd4, 0xc0, 0xfb, 0x4b, 0xd8, 0x56, 0x3b, 0x02, - 0x69, 0x48, 0x17, 0xfc, 0x40, 0x80, 0xbc, 0xdb, 0x1a, 0xf1, 0x9a, 0x99, 0xb4, 0xde, 0xe4, 0xc3, - 0x2e, 0x79, 0xb2, 0x61, 0xe7, 0xf2, 0xf1, 0x83, 0xbd, 0xdf, 0x15, 0x78, 0xb0, 0x72, 0x55, 0x55, - 0x1c, 0xe2, 0x6c, 0xc4, 0x38, 0x54, 0x6e, 0x80, 0x68, 0x29, 0x86, 0x66, 0x36, 0xf5, 0x67, 0x98, - 0xad, 0x88, 0xda, 0x7c, 0x73, 0x73, 0xdc, 0xa3, 0xd3, 0x25, 0x3f, 0x77, 0x41, 0xf7, 0x27, 0x09, - 0x1e, 0xd8, 0xec, 0x15, 0x26, 0x4e, 0xa5, 0x7d, 0x13, 0x26, 0x3a, 0xaf, 0x46, 0x71, 0x47, 0xf1, - 0x2b, 0x11, 0xf2, 0xa2, 0x0a, 0xc2, 0x02, 0x11, 0xdd, 0xc8, 0xf9, 0x8e, 0x6b, 0x52, 0x6c, 0x54, - 0x82, 0x6c, 0xf0, 0xc6, 0x95, 0xe4, 0xc0, 0x37, 0xae, 0x80, 0xe5, 0xdd, 0xb3, 0x32, 0xfd, 0x15, - 0x18, 0xa6, 0xc9, 0xa7, 0x30, 0xdd, 0xbc, 0x4d, 0xff, 0x38, 0x01, 0x97, 0x69, 0xe9, 0x1f, 0x63, - 0x4b, 0xdf, 0x3e, 0xdc, 0xb0, 0x4c, 0x07, 0xab, 0x0e, 0xd6, 0xfc, 0x13, 0x26, 0xb1, 0xda, 0xc3, - 0x4c, 0xcb, 0x7d, 0xc1, 0x89, 0x02, 0xd0, 0x3c, 0x2e, 0xb4, 0x0a, 0xe3, 0x3c, 0x98, 0x40, 0x69, - 0xe8, 0x7b, 0x58, 0x56, 0x9c, 0x93, 0xcc, 0x7a, 0x63, 0x8c, 0x77, 0x81, 0xb0, 0x2e, 0x38, 0x48, - 0x83, 0x0c, 0x17, 0xa6, 0x6b, 0xfc, 0xba, 0xa0, 0xfb, 0x9f, 0x6e, 0x35, 0x31, 0xcd, 0x22, 0x1a, - 0x96, 0x97, 0xa4, 0x34, 0x93, 0xec, 0xed, 0x06, 0xfd, 0x42, 0x80, 0x2b, 0xc7, 0x28, 0x3a, 0xce, - 0x0e, 0x3c, 0x0d, 0xe9, 0x3d, 0xf2, 0x22, 0x9d, 0x6b, 0x3a, 0x2d, 0x79, 0xcf, 0x68, 0x0d, 0xc6, - 0xb6, 0x15, 0xbd, 0xe1, 0x77, 0xec, 0xde, 0x51, 0x8b, 0xd1, 0xc1, 0xb4, 0x39, 0xc6, 0xce, 0x7a, - 0x72, 0xf1, 0x83, 0x04, 0x4c, 0x2c, 0x68, 0x5a, 0xb5, 0xca, 0x6d, 0x63, 0x7c, 0xfd, 0xc5, 0x05, - 0xa5, 0x09, 0x1f, 0x94, 0xa2, 0x57, 0x00, 0x69, 0xba, 0xcd, 0xae, 0x22, 0xb1, 0x77, 0x14, 0xcd, - 0xdc, 0xf7, 0xe3, 0x31, 0x26, 0xdc, 0x94, 0xaa, 0x9b, 0x80, 0xaa, 0x40, 0x11, 0x91, 0x6c, 0x3b, - 0x8a, 0xb7, 0xa5, 0x74, 0x65, 0xa0, 0x03, 0x61, 0x0c, 0x2a, 0x79, 0x8f, 0x52, 0x86, 0xc8, 0xa1, - 0x7f, 0x89, 0x6f, 0xaf, 0x93, 0xaa, 0x3b, 0xb2, 0x62, 0xbb, 0x07, 0x85, 0xd8, 0x25, 0x28, 0x79, - 0x46, 0x5f, 0xb0, 0x83, 0xe7, 0x7f, 0xd8, 0x39, 0x06, 0x5f, 0x41, 0x71, 0x42, 0xe8, 0xff, 0x2a, - 0x40, 0x5e, 0xc2, 0xdb, 0x16, 0xb6, 0x63, 0x5d, 0x4a, 0xb8, 0x07, 0x39, 0x8b, 0x49, 0x95, 0xb7, - 0x2d, 0xb3, 0x79, 0x92, 0x31, 0x96, 0xe5, 0x8c, 0xf7, 0x2c, 0xb3, 0x19, 0xba, 0x17, 0xe2, 0x31, - 0x8c, 0x7b, 0x25, 0x8d, 0x53, 0x05, 0x1f, 0xd1, 0x43, 0xd0, 0x4c, 0x70, 0xdc, 0x81, 0x11, 0x9f, - 0x85, 0x1e, 0xe8, 0x1e, 0x56, 0xb0, 0xb8, 0x71, 0x2a, 0xe3, 0x4f, 0x05, 0xc8, 0x57, 0xdb, 0x5b, - 0xec, 0x26, 0xac, 0xf8, 0xf4, 0x50, 0x86, 0x4c, 0x03, 0x6f, 0x3b, 0xf2, 0xa9, 0x62, 0xef, 0xd3, - 0x84, 0x95, 0x9e, 0x3f, 0xb8, 0x0f, 0x60, 0xd1, 0xd3, 0x75, 0x54, 0x4e, 0xf2, 0x84, 0x72, 0x32, - 0x94, 0xd7, 0x77, 0x9f, 0x8a, 0x1f, 0x25, 0x60, 0xdc, 0xab, 0x6c, 0x9c, 0xd6, 0xf3, 0x49, 0xc8, - 0x6a, 0x24, 0x4f, 0x62, 0x35, 0x26, 0x78, 0x5c, 0x48, 0xb4, 0xe5, 0x98, 0x83, 0x49, 0xea, 0xdc, - 0xc8, 0x4a, 0xab, 0xd5, 0xd0, 0x5d, 0x90, 0x4c, 0xed, 0x52, 0x4a, 0x9a, 0xa0, 0x49, 0x0b, 0x2c, - 0x85, 0xc2, 0x63, 0xd2, 0xff, 0xb6, 0x2d, 0x8c, 0x9f, 0x61, 0x99, 0xe2, 0xb5, 0x93, 0xc4, 0xbd, - 0x64, 0x19, 0x63, 0x95, 0xf0, 0xf1, 0x9e, 0xf7, 0x0d, 0x98, 0xa0, 0x9a, 0x8d, 0xfb, 0xd8, 0x2f, - 0x6f, 0x8e, 0xef, 0x27, 0x00, 0x05, 0xe5, 0x7f, 0x76, 0x2d, 0x92, 0x88, 0xaf, 0x45, 0x5e, 0x06, - 0xc4, 0x62, 0x21, 0x6d, 0xb9, 0x85, 0x2d, 0xd9, 0xc6, 0xaa, 0xc9, 0xef, 0x67, 0x12, 0x24, 0x91, - 0xa7, 0x6c, 0x60, 0xab, 0x4a, 0xe9, 0xe8, 0x2e, 0x80, 0xef, 0xb5, 0xf1, 0xe9, 0xa4, 0xaf, 0xd3, - 0x26, 0x65, 0x3c, 0x77, 0xad, 0xf8, 0xfe, 0x34, 0xe4, 0xb8, 0x26, 0x37, 0x0d, 0xdd, 0x34, 0xd0, - 0x2d, 0x48, 0xd6, 0xf9, 0x36, 0x43, 0x36, 0x72, 0xa1, 0xcf, 0xbf, 0x92, 0xae, 0x32, 0x24, 0x91, - 0xbc, 0x84, 0xa5, 0xd5, 0x76, 0x22, 0x9c, 0x27, 0x3f, 0xe2, 0x3b, 0xc8, 0xd2, 0x6a, 0x3b, 0xa8, - 0x0a, 0xe3, 0xaa, 0x7f, 0xc1, 0x96, 0x4c, 0xd8, 0x93, 0x3d, 0x01, 0x58, 0xe4, 0xc5, 0x66, 0x95, - 0x21, 0x29, 0xaf, 0x86, 0x12, 0x50, 0x29, 0x78, 0xa3, 0x53, 0xaa, 0x2b, 0x60, 0xcc, 0x3f, 0x5f, - 0x1c, 0xbe, 0x4d, 0xaa, 0x32, 0x14, 0xb8, 0xf8, 0x09, 0xbd, 0x05, 0x23, 0x1a, 0xbd, 0x29, 0x88, - 0xf7, 0xeb, 0xa8, 0xae, 0x17, 0xba, 0x9c, 0xa9, 0x32, 0x24, 0x71, 0x0e, 0xb4, 0x02, 0x39, 0xf6, - 0x8f, 0x39, 0x31, 0x1c, 0x95, 0x5e, 0xe9, 0x2d, 0x21, 0x30, 0x35, 0x54, 0x86, 0xa4, 0xac, 0xe6, - 0x53, 0xd1, 0x6b, 0x90, 0xb2, 0x55, 0xc5, 0xc5, 0xa5, 0x17, 0x7b, 0x5c, 0xf2, 0xe1, 0x33, 0xd3, - 0xdc, 0xe8, 0x2e, 0xbb, 0x6a, 0xd2, 0x39, 0x70, 0x17, 0x0a, 0xa3, 0x8a, 0x1f, 0x3a, 0x3a, 0x4e, - 0x8a, 0x8f, 0x29, 0x01, 0xdd, 0x87, 0xac, 0x42, 0xbc, 0x41, 0x99, 0x9e, 0xca, 0xa4, 0x2b, 0x83, - 0xd1, 0x7b, 0xf0, 0x5d, 0x27, 0x6a, 0x2b, 0xf4, 0x7c, 0xba, 0x4b, 0xf4, 0x05, 0x35, 0xb1, 0x55, - 0xc7, 0x85, 0x6c, 0x7f, 0x41, 0xc1, 0x00, 0x31, 0x4f, 0x10, 0x25, 0x12, 0xaf, 0x70, 0xc7, 0x3d, - 0x71, 0x43, 0x2b, 0x95, 0xeb, 0xb9, 0xdf, 0x1b, 0x71, 0x62, 0xa8, 0x32, 0x24, 0xe5, 0x76, 0x02, - 0x64, 0x34, 0x07, 0x89, 0xba, 0x5a, 0x18, 0xeb, 0x39, 0x42, 0xbc, 0xf3, 0x30, 0x95, 0x21, 0x29, - 0x51, 0x57, 0xd1, 0x3b, 0x90, 0x66, 0x07, 0x1a, 0x0e, 0x8c, 0x42, 0xbe, 0xa7, 0x9d, 0x08, 0x1f, - 0x0b, 0xa9, 0x0c, 0x49, 0xf4, 0x0c, 0x05, 0x79, 0xdf, 0x06, 0xe4, 0x2d, 0x16, 0x61, 0xe7, 0xc6, - 0xc6, 0x8a, 0x3d, 0xf7, 0xc0, 0xa3, 0xc2, 0x63, 0x2b, 0x14, 0x1d, 0x04, 0xe8, 0xe8, 0x9b, 0x30, - 0x15, 0x96, 0xc8, 0x7b, 0xda, 0x44, 0xcf, 0xfd, 0xdc, 0x9e, 0x41, 0x9a, 0x95, 0x21, 0x09, 0x59, - 0x5d, 0x89, 0xe8, 0x0d, 0x18, 0x66, 0xad, 0x86, 0xa8, 0xc8, 0xa8, 0xe0, 0x8e, 0x8e, 0x06, 0x63, - 0xf9, 0x49, 0xe7, 0x77, 0x78, 0x68, 0x99, 0xdc, 0x30, 0xeb, 0x85, 0xc9, 0x9e, 0x9d, 0xbf, 0x3b, - 0x54, 0x8e, 0x74, 0x7e, 0xc7, 0xa7, 0x92, 0x76, 0xb7, 0x58, 0x0a, 0x8f, 0x44, 0x9a, 0xea, 0xd9, - 0xee, 0x11, 0x11, 0x67, 0x15, 0x7a, 0x30, 0xc0, 0x27, 0x93, 0xa2, 0x59, 0xec, 0x46, 0x1a, 0x99, - 0x8e, 0xa9, 0x33, 0x3d, 0x8b, 0xd6, 0x7d, 0x71, 0x4f, 0x85, 0x7a, 0x4d, 0x1e, 0x15, 0x3d, 0x06, - 0x91, 0xdf, 0x15, 0xe1, 0xef, 0x4a, 0x9c, 0xa5, 0xf2, 0x6e, 0x44, 0x9a, 0xae, 0xa8, 0xd0, 0x9d, - 0xca, 0x90, 0x34, 0xae, 0x86, 0x53, 0xd0, 0xbb, 0x30, 0x41, 0xe5, 0xc9, 0xaa, 0x7f, 0xc9, 0x47, - 0xa1, 0xd0, 0x75, 0x59, 0x44, 0xef, 0xfb, 0x40, 0x5c, 0xc9, 0xa2, 0xda, 0x91, 0x44, 0xba, 0xb1, - 0x6e, 0xe8, 0x0e, 0xb5, 0xb2, 0xd3, 0x3d, 0xbb, 0x71, 0xf8, 0x42, 0x42, 0xd2, 0x8d, 0x75, 0x46, - 0x21, 0xdd, 0xd8, 0xe1, 0x61, 0x6a, 0xbc, 0x39, 0x5e, 0xe8, 0xd9, 0x8d, 0xa3, 0xe2, 0xd9, 0x48, - 0x37, 0x76, 0x82, 0x74, 0xd2, 0x8d, 0x99, 0x81, 0xe8, 0x90, 0xfb, 0x62, 0xcf, 0x6e, 0xdc, 0xf3, - 0x5c, 0x34, 0xe9, 0xc6, 0x4a, 0x57, 0x22, 0x5a, 0x02, 0x60, 0x4e, 0x0d, 0x9d, 0x14, 0x2f, 0xf6, - 0x9c, 0x0c, 0x3a, 0x03, 0xd5, 0xc8, 0x64, 0xd0, 0x70, 0x69, 0xc4, 0x90, 0x51, 0x28, 0x25, 0xd3, - 0x2d, 0xda, 0xc2, 0x4c, 0x4f, 0x43, 0xd6, 0xb5, 0x79, 0x4a, 0x0c, 0xd9, 0xbe, 0x47, 0x24, 0xb3, - 0x0a, 0x5b, 0x2f, 0x2e, 0xcc, 0xf6, 0x36, 0xcb, 0xc1, 0xcd, 0x23, 0x6a, 0x96, 0x29, 0x01, 0x2d, - 0x40, 0x86, 0xcc, 0xf9, 0x87, 0xd4, 0x0c, 0x5d, 0xea, 0xe9, 0x9f, 0x76, 0x9c, 0x7c, 0xa9, 0x0c, - 0x49, 0xe9, 0xa7, 0x9c, 0x44, 0x5e, 0xcf, 0xd6, 0xcd, 0x0a, 0xc5, 0x9e, 0xaf, 0x0f, 0xad, 0xba, - 0x92, 0xd7, 0x33, 0x0e, 0xa4, 0xc2, 0x19, 0xd6, 0x56, 0xfc, 0x58, 0xb2, 0xc5, 0xcf, 0xd0, 0x16, - 0x5e, 0xa2, 0xa2, 0x7a, 0x2e, 0x3d, 0x45, 0x9e, 0x96, 0xae, 0x0c, 0x49, 0x93, 0x4a, 0x77, 0x2a, - 0x19, 0xf0, 0x7c, 0xea, 0x61, 0x0b, 0x56, 0x85, 0xcb, 0x3d, 0x07, 0x7c, 0xc4, 0x6a, 0x1f, 0x19, - 0xf0, 0x4a, 0x80, 0xcc, 0x26, 0x20, 0x4d, 0xb6, 0x6d, 0xb6, 0xa1, 0x7f, 0xa5, 0xcf, 0x04, 0xd4, - 0xb1, 0x46, 0xc0, 0x26, 0x20, 0xad, 0xca, 0x38, 0x89, 0x20, 0xb5, 0x81, 0x15, 0x8b, 0x9b, 0xd9, - 0xab, 0x3d, 0x05, 0x75, 0xdd, 0xf1, 0x47, 0x04, 0xa9, 0x1e, 0x91, 0x38, 0x3c, 0x96, 0x7b, 0xc9, - 0x0c, 0x77, 0x18, 0xaf, 0xf5, 0x74, 0x78, 0x22, 0xef, 0xc2, 0x21, 0x0e, 0x8f, 0x15, 0x4a, 0x40, - 0x5f, 0x82, 0x51, 0x0e, 0xe8, 0x0a, 0xd7, 0xfb, 0xb8, 0xb1, 0x41, 0x24, 0x4e, 0xc6, 0x35, 0xe7, - 0x61, 0x56, 0x96, 0x01, 0x49, 0x56, 0xbd, 0x1b, 0x7d, 0xac, 0x6c, 0x17, 0x96, 0x65, 0x56, 0xd6, - 0x27, 0x13, 0x2b, 0xcb, 0xfa, 0x29, 0x9f, 0xeb, 0x6e, 0xf6, 0xb4, 0xb2, 0xdd, 0x27, 0x6a, 0x88, - 0x95, 0x7d, 0xea, 0x53, 0x49, 0xcd, 0x6c, 0x06, 0xa2, 0x0a, 0x5f, 0xe8, 0x59, 0xb3, 0x30, 0xa6, - 0x24, 0x35, 0xe3, 0x3c, 0xa4, 0xd9, 0x98, 0x4b, 0xcc, 0x34, 0xfd, 0x72, 0xef, 0x1b, 0x00, 0x3a, - 0xa1, 0x47, 0xc5, 0x5d, 0xcc, 0x64, 0x1a, 0xf6, 0x0c, 0x95, 0xc5, 0xcf, 0x3b, 0x73, 0x4d, 0xbd, - 0xd2, 0xdf, 0x50, 0x45, 0x1d, 0xe5, 0xf6, 0x0c, 0x55, 0x28, 0x91, 0x16, 0x95, 0x1d, 0x62, 0xa3, - 0xe3, 0x7b, 0xae, 0xcf, 0x65, 0x05, 0x1d, 0x07, 0x0a, 0x69, 0x51, 0x3d, 0xa2, 0x3f, 0x84, 0xda, - 0xec, 0x56, 0x8d, 0xc2, 0x7c, 0xff, 0x21, 0x14, 0xbe, 0xdd, 0xc3, 0x1b, 0x42, 0x9c, 0xec, 0xcd, - 0x99, 0xae, 0x87, 0xf1, 0x6a, 0xff, 0x39, 0xb3, 0xd3, 0xb5, 0x60, 0x73, 0x26, 0xf7, 0x29, 0xfe, - 0x89, 0x00, 0xb3, 0xac, 0x6c, 0x74, 0xbd, 0xef, 0x50, 0xf6, 0xd6, 0x4e, 0x03, 0xc7, 0x27, 0x6e, - 0xd1, 0x17, 0xbc, 0xd1, 0xab, 0xb8, 0xc7, 0xac, 0x05, 0x57, 0x86, 0xa4, 0x17, 0x95, 0x7e, 0xf9, - 0x16, 0x47, 0xf9, 0x96, 0xaa, 0x77, 0x8e, 0x74, 0x5c, 0x14, 0x57, 0x52, 0xe9, 0x73, 0x62, 0x61, - 0x25, 0x95, 0x3e, 0x2f, 0x4e, 0xaf, 0xa4, 0xd2, 0x17, 0xc4, 0x17, 0x8a, 0x7f, 0x76, 0x1e, 0xc6, - 0x5c, 0xe4, 0xc7, 0x10, 0xd1, 0xed, 0x20, 0x22, 0xba, 0xd8, 0x0b, 0x11, 0x71, 0xac, 0xc8, 0x21, - 0xd1, 0xed, 0x20, 0x24, 0xba, 0xd8, 0x0b, 0x12, 0xf9, 0x3c, 0x04, 0x13, 0xd5, 0x7a, 0x61, 0xa2, - 0x1b, 0x03, 0x60, 0x22, 0x4f, 0x54, 0x27, 0x28, 0x5a, 0xea, 0x06, 0x45, 0x97, 0xfb, 0x83, 0x22, - 0x4f, 0x54, 0x00, 0x15, 0xdd, 0xed, 0x40, 0x45, 0x97, 0xfa, 0xa0, 0x22, 0x8f, 0xdf, 0x85, 0x45, - 0xab, 0x91, 0xb0, 0xe8, 0xea, 0x71, 0xb0, 0xc8, 0x93, 0x13, 0xc2, 0x45, 0xaf, 0x87, 0x70, 0xd1, - 0x4c, 0x4f, 0x5c, 0xe4, 0x71, 0x33, 0x60, 0xf4, 0x76, 0x27, 0x30, 0xba, 0xd4, 0x07, 0x18, 0xf9, - 0x35, 0xe0, 0xc8, 0xa8, 0x12, 0x85, 0x8c, 0xae, 0x1c, 0x83, 0x8c, 0x3c, 0x29, 0x41, 0x68, 0x54, - 0x89, 0x82, 0x46, 0x57, 0x8e, 0x81, 0x46, 0x1d, 0x92, 0x18, 0x36, 0x5a, 0x8f, 0xc6, 0x46, 0xd7, - 0x8e, 0xc5, 0x46, 0x9e, 0xb4, 0x30, 0x38, 0x9a, 0x0f, 0x80, 0xa3, 0x17, 0x7b, 0x80, 0x23, 0x8f, - 0x95, 0xa0, 0xa3, 0x2f, 0x77, 0xa1, 0xa3, 0x62, 0x3f, 0x74, 0xe4, 0xf1, 0x7a, 0xf0, 0xe8, 0x51, - 0x0f, 0x78, 0x74, 0xfd, 0x78, 0x78, 0xe4, 0x09, 0xeb, 0xc0, 0x47, 0x4a, 0x5f, 0x7c, 0xf4, 0xca, - 0x80, 0xf8, 0xc8, 0x93, 0x1e, 0x05, 0x90, 0xde, 0x0c, 0x03, 0xa4, 0xd9, 0xde, 0x00, 0xc9, 0x13, - 0xc3, 0x11, 0xd2, 0x6a, 0x24, 0x42, 0xba, 0x7a, 0x1c, 0x42, 0xf2, 0xc7, 0x41, 0x10, 0x22, 0xad, - 0x47, 0x43, 0xa4, 0x6b, 0xc7, 0x42, 0x24, 0xbf, 0xf9, 0x43, 0x18, 0x69, 0x35, 0x12, 0x23, 0x5d, - 0x3d, 0x0e, 0x23, 0xf9, 0x85, 0x0b, 0x82, 0xa4, 0x27, 0x3d, 0x41, 0xd2, 0xcd, 0x41, 0x40, 0x92, - 0x27, 0xb4, 0x0b, 0x25, 0xbd, 0xd7, 0x1b, 0x25, 0x7d, 0xe1, 0x04, 0xb7, 0x26, 0x46, 0xc2, 0xa4, - 0x2f, 0x77, 0xc1, 0xa4, 0x62, 0x3f, 0x98, 0xe4, 0xf7, 0x67, 0x17, 0x27, 0x29, 0x7d, 0x51, 0xcd, - 0x2b, 0x03, 0xa2, 0x1a, 0xbf, 0xf3, 0x45, 0xc0, 0x9a, 0x72, 0x04, 0xac, 0xb9, 0xdc, 0x1f, 0xd6, - 0xf8, 0xe6, 0xdc, 0xc7, 0x35, 0x95, 0x28, 0x5c, 0x73, 0xe5, 0x18, 0x5c, 0xe3, 0x5b, 0xa1, 0x00, - 0xb0, 0xb9, 0xdb, 0x01, 0x6c, 0x2e, 0x1d, 0x1b, 0x31, 0x14, 0x40, 0x36, 0x8b, 0xdd, 0xc8, 0xe6, - 0xa5, 0xbe, 0xc8, 0xc6, 0x93, 0xe0, 0x43, 0x9b, 0xbb, 0x1d, 0xd0, 0xe6, 0x52, 0x1f, 0x68, 0xe3, - 0x17, 0x80, 0x63, 0x1b, 0xad, 0x3f, 0xb6, 0x99, 0x1b, 0x14, 0xdb, 0x78, 0x82, 0x23, 0xc1, 0xcd, - 0x7a, 0x34, 0xb8, 0xb9, 0x36, 0xe0, 0xa6, 0x7d, 0x17, 0xba, 0xa9, 0x44, 0xa1, 0x9b, 0x2b, 0xc7, - 0xa0, 0x9b, 0xe0, 0x1c, 0xe2, 0xc1, 0x9b, 0x4a, 0x14, 0xbc, 0xb9, 0x72, 0x0c, 0xbc, 0xf1, 0x25, - 0x05, 0xf0, 0x4d, 0xad, 0x17, 0xbe, 0xb9, 0x31, 0x00, 0xbe, 0xf1, 0x9d, 0x97, 0x0e, 0x80, 0xf3, - 0x4e, 0x27, 0xc0, 0x29, 0xf6, 0x03, 0x38, 0xfe, 0x88, 0x74, 0x11, 0xce, 0x7a, 0x34, 0xc2, 0xb9, - 0x76, 0x2c, 0xc2, 0x09, 0x1a, 0xc9, 0x00, 0xc4, 0x59, 0x8d, 0x84, 0x38, 0x57, 0x8f, 0x83, 0x38, - 0xbe, 0x91, 0x0c, 0x62, 0x9c, 0x77, 0x3a, 0x31, 0x4e, 0xb1, 0x1f, 0xc6, 0xf1, 0x2b, 0xe7, 0x82, - 0x9c, 0x4a, 0x14, 0xc8, 0xb9, 0x72, 0x0c, 0xc8, 0xf1, 0x1b, 0x2f, 0x80, 0x72, 0x94, 0xbe, 0x28, - 0xe7, 0x95, 0x01, 0x51, 0x4e, 0x87, 0xe1, 0x0a, 0xc3, 0x9c, 0x4a, 0x14, 0xcc, 0xb9, 0x72, 0x0c, - 0xcc, 0x09, 0x14, 0xd6, 0xc7, 0x39, 0xeb, 0xd1, 0x38, 0xe7, 0xda, 0xb1, 0x38, 0xa7, 0x63, 0x34, - 0xb9, 0x40, 0x67, 0x35, 0x12, 0xe8, 0x5c, 0x3d, 0x0e, 0xe8, 0x74, 0x4c, 0x7c, 0xdc, 0x39, 0xf8, - 0xa7, 0x83, 0x23, 0x9d, 0x37, 0x4f, 0x8e, 0x74, 0xbc, 0x77, 0xc6, 0x02, 0x75, 0x56, 0x52, 0xe9, - 0x17, 0xc4, 0x17, 0x8b, 0xff, 0x72, 0x14, 0x46, 0x2a, 0x5e, 0x2c, 0x8c, 0x5f, 0x4a, 0xe1, 0x34, - 0x97, 0x31, 0xa1, 0x25, 0x32, 0x62, 0xa9, 0xdd, 0x3b, 0xfe, 0xde, 0xbd, 0xee, 0x3b, 0xe1, 0x38, - 0xeb, 0x29, 0xce, 0x37, 0xa3, 0xd7, 0x61, 0xac, 0x6d, 0x63, 0x4b, 0x6e, 0x59, 0xba, 0x69, 0xe9, - 0x0e, 0x3b, 0x2b, 0x22, 0x2c, 0x8a, 0x9f, 0x1c, 0xcd, 0xe4, 0x36, 0x6d, 0x6c, 0x6d, 0x70, 0xba, - 0x94, 0x6b, 0x07, 0x9e, 0xdc, 0xcf, 0x5e, 0x0d, 0x0f, 0xfe, 0xd9, 0xab, 0x47, 0x20, 0x5a, 0x58, - 0xd1, 0x42, 0x1e, 0x08, 0xbb, 0xec, 0x28, 0xba, 0xcf, 0xd0, 0x63, 0x58, 0x6e, 0x4e, 0x7a, 0xe9, - 0xd1, 0xb8, 0x15, 0x26, 0xa2, 0x5b, 0x70, 0xa6, 0xa9, 0x1c, 0xd0, 0x78, 0x4a, 0xd9, 0x75, 0xea, - 0x68, 0x8c, 0x24, 0xfb, 0xa2, 0x14, 0x6a, 0x2a, 0x07, 0xf4, 0x1b, 0x5a, 0x2c, 0x89, 0x7e, 0xf4, - 0xe2, 0x0a, 0xe4, 0x35, 0xdd, 0x76, 0x74, 0x43, 0x75, 0xf8, 0xdd, 0xb7, 0xec, 0xde, 0xd8, 0x31, - 0x97, 0xca, 0x2e, 0xb8, 0xbd, 0x09, 0x13, 0x3c, 0xdc, 0x3e, 0xb0, 0x45, 0x08, 0x3c, 0x86, 0x8d, - 0x26, 0x78, 0xbb, 0x82, 0xa8, 0x04, 0xe3, 0x75, 0xc5, 0xc1, 0xfb, 0xca, 0xa1, 0xec, 0x9e, 0xd5, - 0xca, 0xd2, 0x5b, 0x22, 0x2f, 0x3c, 0x3f, 0x9a, 0x19, 0xbb, 0xcf, 0x92, 0xba, 0x8e, 0x6c, 0x8d, - 0xd5, 0x03, 0x09, 0x1a, 0xba, 0x06, 0xe3, 0x8a, 0x7d, 0x68, 0xa8, 0x54, 0x3d, 0xd8, 0xb0, 0xdb, - 0x36, 0x85, 0x14, 0x69, 0x29, 0x4f, 0xc9, 0x25, 0x97, 0x8a, 0x2e, 0x41, 0x8e, 0xc7, 0xa2, 0xb3, - 0x0f, 0xf1, 0x8c, 0xd3, 0xaa, 0xf2, 0xaf, 0x3a, 0xd0, 0x6f, 0xf1, 0xa0, 0xbb, 0x30, 0xcd, 0x6f, - 0xbb, 0xdf, 0x57, 0x2c, 0x4d, 0xa6, 0x5a, 0xf7, 0xfb, 0xa7, 0x48, 0xc5, 0x9e, 0x63, 0xb7, 0xdb, - 0x93, 0x0c, 0x44, 0xd5, 0xfe, 0xa5, 0x0a, 0xeb, 0x30, 0xa1, 0x36, 0x74, 0x0f, 0x01, 0xb0, 0x9a, - 0x4f, 0xf4, 0xb4, 0xb3, 0x25, 0x9a, 0xd7, 0xdf, 0x22, 0x1d, 0x57, 0xc3, 0x04, 0x54, 0x05, 0x7a, - 0x89, 0x8c, 0xdc, 0x32, 0x1b, 0xba, 0x7a, 0x48, 0x9d, 0xff, 0xf0, 0x4d, 0xdd, 0x7d, 0xef, 0xce, - 0x7f, 0xa2, 0xe8, 0xce, 0x06, 0xe5, 0x94, 0x60, 0xdf, 0xfb, 0xcf, 0x2e, 0xe1, 0x5d, 0x49, 0xa5, - 0x73, 0xe2, 0xd8, 0x4a, 0x2a, 0x9d, 0x17, 0xc7, 0x8b, 0xff, 0x56, 0x80, 0xf1, 0x8e, 0xb2, 0xa0, - 0x0a, 0x9c, 0xd1, 0xbc, 0xa1, 0x22, 0xf3, 0xa3, 0x4c, 0xba, 0x69, 0xf0, 0xcb, 0xc7, 0x27, 0x3f, - 0x39, 0x9a, 0x19, 0xa7, 0xb9, 0xef, 0x7b, 0x49, 0xd2, 0x94, 0xcf, 0xe1, 0x53, 0xd1, 0x9b, 0x90, - 0x67, 0xee, 0xa3, 0xf7, 0xb5, 0x39, 0x1a, 0x5f, 0xbe, 0x38, 0xf1, 0xc9, 0xd1, 0xcc, 0x18, 0xf5, - 0x19, 0xdd, 0x1b, 0x84, 0xa5, 0xb1, 0x46, 0xf0, 0xb1, 0xf8, 0x6f, 0x04, 0xc8, 0x85, 0x0e, 0x07, - 0xdd, 0xed, 0xd8, 0x41, 0x3f, 0x1f, 0x8d, 0x3b, 0x7b, 0x05, 0xdd, 0xa5, 0x79, 0x3f, 0x77, 0x23, - 0x18, 0x67, 0x7a, 0xe3, 0x16, 0xba, 0x0a, 0xe3, 0x86, 0x6d, 0xb8, 0x6c, 0x6f, 0xa5, 0xfe, 0xfd, - 0x87, 0x33, 0x43, 0xc5, 0x8f, 0x52, 0x30, 0x16, 0x3e, 0x04, 0xb4, 0xdc, 0x51, 0xae, 0xa8, 0x79, - 0x21, 0xc4, 0x31, 0xd7, 0xe7, 0xde, 0xc4, 0x8c, 0x7f, 0xd7, 0x3f, 0x2b, 0xe6, 0x6c, 0x9f, 0x38, - 0x81, 0x60, 0x39, 0x7d, 0xc6, 0xe9, 0x7f, 0x96, 0xf4, 0xec, 0xeb, 0x1c, 0x0c, 0xd3, 0xdb, 0x79, - 0x78, 0xd1, 0xa2, 0xce, 0x97, 0x97, 0x49, 0xba, 0xc4, 0xb2, 0x11, 0x7b, 0x5c, 0x3b, 0xd5, 0xe5, - 0x78, 0xfe, 0x30, 0x38, 0xf9, 0x67, 0xfd, 0xf8, 0x15, 0x89, 0xc3, 0x27, 0xbb, 0x22, 0x91, 0xed, - 0xe8, 0x37, 0x1a, 0x6c, 0xae, 0x63, 0x16, 0x69, 0xa4, 0xeb, 0x10, 0x37, 0x15, 0xc1, 0xbf, 0xb6, - 0x38, 0x27, 0xf1, 0xaf, 0x2d, 0x06, 0xa2, 0x40, 0xf3, 0x9e, 0x08, 0x66, 0xbe, 0x3a, 0x02, 0x52, - 0x47, 0x4f, 0x13, 0x90, 0xca, 0x42, 0x99, 0x79, 0x7f, 0xf9, 0x1d, 0x81, 0x87, 0x83, 0x3c, 0x30, - 0xcd, 0xdd, 0xb6, 0x17, 0x48, 0x3a, 0x1d, 0xbc, 0xa0, 0x30, 0xfd, 0xc9, 0xd1, 0x4c, 0x4a, 0xf2, - 0x6e, 0x28, 0x8c, 0xb2, 0xf7, 0x89, 0x4f, 0x67, 0xef, 0x2f, 0x41, 0xae, 0x65, 0xe1, 0x6d, 0xec, - 0xa8, 0x3b, 0xb2, 0xd1, 0x6e, 0xf2, 0x73, 0x28, 0x59, 0x97, 0xb6, 0xde, 0x6e, 0xa2, 0x1b, 0x20, - 0x7a, 0x59, 0x38, 0xb2, 0x76, 0xef, 0xa8, 0x72, 0xe9, 0x1c, 0x87, 0x17, 0xff, 0x42, 0x80, 0xc9, - 0x50, 0x9d, 0xf8, 0x48, 0x58, 0x81, 0xac, 0x6f, 0x04, 0xec, 0x82, 0x70, 0xc2, 0x80, 0xca, 0x20, - 0x33, 0x92, 0xe1, 0xac, 0xfb, 0x5a, 0x7a, 0x93, 0xbd, 0x2f, 0x36, 0x71, 0x42, 0xb1, 0x67, 0x7c, - 0x39, 0x4b, 0x81, 0x17, 0x78, 0x43, 0x23, 0x39, 0xd0, 0xd0, 0x28, 0x7e, 0x20, 0x80, 0x48, 0x5f, - 0x70, 0x0f, 0x63, 0x2d, 0x16, 0x9b, 0xe4, 0x86, 0x2b, 0x27, 0x06, 0x3f, 0x69, 0x12, 0xfa, 0x12, - 0x47, 0x32, 0xfc, 0x25, 0x8e, 0xe2, 0x87, 0x02, 0xe4, 0xbd, 0x12, 0xb2, 0xaf, 0xd8, 0xf5, 0xb9, - 0x07, 0xf3, 0x74, 0xdf, 0x6e, 0x73, 0xaf, 0xeb, 0x18, 0xe8, 0xc3, 0x7a, 0xc1, 0xeb, 0x3a, 0xd8, - 0x77, 0xc6, 0xfe, 0xa3, 0xdb, 0x73, 0x48, 0x11, 0x4b, 0xfe, 0x55, 0x0c, 0xa7, 0x38, 0x74, 0x23, - 0xd1, 0x8f, 0x81, 0x9a, 0x8d, 0x3d, 0x76, 0x4f, 0xca, 0x40, 0xc6, 0x0a, 0xf1, 0x20, 0x28, 0xe0, - 0x6b, 0x70, 0x5a, 0xad, 0x4a, 0x3f, 0x13, 0xca, 0xfe, 0xdb, 0xc5, 0x7b, 0x01, 0x05, 0xd2, 0xc6, - 0x27, 0x5a, 0x1a, 0xc8, 0x80, 0xba, 0x5a, 0x62, 0x7d, 0xe5, 0x67, 0xc1, 0x96, 0x28, 0xef, 0x11, - 0xec, 0x75, 0x07, 0x92, 0x7b, 0x4a, 0xa3, 0x5f, 0xf0, 0x57, 0xa8, 0xe5, 0x24, 0x92, 0x1b, 0xdd, - 0x0b, 0xdd, 0x60, 0x91, 0xe8, 0x8d, 0x13, 0xba, 0x55, 0x1a, 0xba, 0xe9, 0xe2, 0x8d, 0x70, 0x5f, - 0xef, 0xfb, 0xfa, 0x60, 0xa7, 0x7f, 0x2b, 0xf5, 0xf1, 0x87, 0x33, 0x42, 0xf1, 0x0d, 0x38, 0x7f, - 0xdf, 0xb4, 0x6d, 0xbd, 0x45, 0xb0, 0x21, 0x1d, 0x40, 0xc4, 0x76, 0x7b, 0x96, 0x2c, 0xdd, 0xa2, - 0xab, 0x04, 0x06, 0x1b, 0xf1, 0x19, 0xc9, 0x7b, 0x2e, 0xfe, 0x6f, 0x01, 0xce, 0x75, 0x73, 0x32, - 0x85, 0x44, 0x1d, 0xea, 0x1b, 0x55, 0x4d, 0xff, 0x46, 0xb7, 0xe3, 0x3b, 0x96, 0x9b, 0x9d, 0xf8, - 0x80, 0xfc, 0x9d, 0x72, 0x53, 0xa1, 0x23, 0x9d, 0x1f, 0x3c, 0xce, 0x73, 0xf2, 0x1a, 0xa3, 0xfa, - 0x83, 0x3e, 0x35, 0xd0, 0xa0, 0xbf, 0x59, 0x85, 0xc9, 0x08, 0xfb, 0x8a, 0xf2, 0x00, 0x81, 0x2f, - 0x93, 0xf0, 0x6f, 0xaa, 0x2e, 0x2c, 0xc9, 0x9b, 0xeb, 0xa5, 0x87, 0x6b, 0x6b, 0xcb, 0xb5, 0x5a, - 0x79, 0x49, 0x14, 0x90, 0x08, 0xb9, 0xd0, 0x77, 0x4d, 0x12, 0xec, 0x2b, 0xab, 0x37, 0xff, 0x01, - 0x80, 0xff, 0xb9, 0x24, 0x22, 0x6b, 0xb5, 0xfc, 0xae, 0xfc, 0x78, 0xe1, 0xc1, 0x66, 0xb9, 0x2a, - 0x0e, 0x21, 0x04, 0xf9, 0xc5, 0x85, 0x5a, 0xa9, 0x22, 0x4b, 0xe5, 0xea, 0xc6, 0xc3, 0xf5, 0x6a, - 0xd9, 0xfd, 0x3a, 0xeb, 0xcd, 0x25, 0xc8, 0x05, 0x6f, 0x39, 0x41, 0x93, 0x30, 0x5e, 0xaa, 0x94, - 0x4b, 0xab, 0xf2, 0xe3, 0xe5, 0x05, 0xf9, 0xd1, 0x66, 0x79, 0xb3, 0x2c, 0x0e, 0xd1, 0xa2, 0x51, - 0xe2, 0xbd, 0xcd, 0x07, 0x0f, 0x44, 0x01, 0x8d, 0x43, 0x96, 0x3d, 0xd3, 0x6f, 0xa0, 0x88, 0x89, - 0x9b, 0x6b, 0x90, 0x0d, 0xdc, 0x87, 0x4a, 0x5e, 0xb7, 0xb1, 0x59, 0xad, 0xc8, 0xb5, 0xe5, 0xb5, - 0x72, 0xb5, 0xb6, 0xb0, 0xb6, 0xc1, 0x64, 0x50, 0xda, 0xc2, 0xe2, 0x43, 0xa9, 0x26, 0x0a, 0xde, - 0x73, 0xed, 0xe1, 0x66, 0xa9, 0xe2, 0x56, 0xa3, 0x98, 0x4a, 0x27, 0xc5, 0xe4, 0xcd, 0x6f, 0x0b, - 0x70, 0xae, 0xc7, 0x5d, 0x1f, 0x28, 0x0b, 0xa3, 0x9b, 0x06, 0xbd, 0x10, 0x52, 0x1c, 0x42, 0x63, - 0x81, 0xeb, 0x3e, 0x44, 0x01, 0xa5, 0xd9, 0x55, 0x0b, 0x62, 0x02, 0x8d, 0x40, 0xa2, 0x7a, 0x47, - 0x4c, 0x92, 0x92, 0x06, 0x6e, 0xcb, 0x10, 0x53, 0x28, 0xc3, 0x0f, 0xfb, 0x8b, 0xc3, 0x28, 0xe7, - 0x9f, 0xb6, 0x17, 0x47, 0x88, 0x28, 0xef, 0xbc, 0xba, 0x38, 0x7a, 0xf3, 0x12, 0x04, 0xce, 0xfe, - 0x22, 0x80, 0x91, 0x07, 0x8a, 0x83, 0x6d, 0x47, 0x1c, 0x42, 0xa3, 0x90, 0x5c, 0x68, 0x34, 0x44, - 0xe1, 0xf6, 0x3f, 0x4f, 0x42, 0xda, 0xfd, 0xca, 0x07, 0x7a, 0x00, 0xc3, 0x6c, 0x29, 0x71, 0xa6, - 0xb7, 0xa7, 0x46, 0xfb, 0xf6, 0xf4, 0xec, 0x71, 0xae, 0x5c, 0x71, 0x08, 0xfd, 0x43, 0xc8, 0x06, - 0xe6, 0x42, 0xd4, 0x73, 0x39, 0x24, 0x34, 0xff, 0x4f, 0x5f, 0x3d, 0x2e, 0x9b, 0x27, 0xff, 0x09, - 0x64, 0xbc, 0xb1, 0x89, 0x5e, 0xea, 0x37, 0x72, 0x5d, 0xd9, 0xfd, 0x87, 0x37, 0x19, 0x7c, 0xc5, - 0xa1, 0x57, 0x05, 0x64, 0x01, 0xea, 0x1e, 0x9b, 0x28, 0x6a, 0x87, 0xb9, 0xe7, 0xe0, 0x9f, 0xbe, - 0x39, 0x50, 0x6e, 0xef, 0x9d, 0x8b, 0x37, 0x3e, 0xfe, 0xd5, 0xc5, 0xa1, 0x8f, 0x9f, 0x5f, 0x14, - 0x7e, 0xfe, 0xfc, 0xa2, 0xf0, 0xcb, 0xe7, 0x17, 0x85, 0x3f, 0x7a, 0x7e, 0x51, 0xf8, 0xd7, 0xbf, - 0xbe, 0x38, 0xf4, 0xf3, 0x5f, 0x5f, 0x1c, 0xfa, 0xe5, 0xaf, 0x2f, 0x0e, 0xbd, 0x37, 0xca, 0xc5, - 0x6c, 0x8d, 0xd0, 0xef, 0x5e, 0xdf, 0xf9, 0xdb, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb0, 0x74, 0x5b, - 0x6f, 0x1a, 0x7c, 0x00, 0x00, + 0x43, 0x1c, 0x9e, 0x23, 0x98, 0x0d, 0x15, 0x2f, 0xde, 0xa6, 0x4c, 0xd1, 0x92, 0x25, 0x16, 0x93, + 0x41, 0xdf, 0x8e, 0x12, 0x4b, 0x7f, 0x57, 0x82, 0x99, 0x72, 0x0b, 0xab, 0x76, 0xec, 0x7a, 0xf9, + 0x36, 0xa4, 0x75, 0xac, 0xea, 0xb4, 0xe2, 0x6c, 0xc0, 0xbf, 0x13, 0x90, 0x42, 0xfc, 0xda, 0xa5, + 0xfd, 0x96, 0xb6, 0xd4, 0x10, 0x1e, 0x2f, 0x1f, 0xf5, 0x1e, 0x13, 0xef, 0x10, 0x9f, 0x01, 0x0a, + 0x96, 0x2f, 0xce, 0x4e, 0xf1, 0xf7, 0x24, 0x40, 0x32, 0x3e, 0xc4, 0xb6, 0x1b, 0x7b, 0xe5, 0xd7, + 0x20, 0xeb, 0xaa, 0x76, 0x13, 0xbb, 0x0a, 0xf1, 0xe8, 0x2f, 0x52, 0x7f, 0x60, 0x7c, 0x84, 0xcc, + 0x35, 0xf0, 0x39, 0xcc, 0x86, 0x4a, 0x19, 0xa7, 0x0a, 0xfe, 0x97, 0x04, 0xd9, 0xba, 0xa6, 0x9a, + 0x71, 0xd6, 0xfd, 0x53, 0xc8, 0x3a, 0x9a, 0x6a, 0x2a, 0x7b, 0x96, 0xdd, 0x56, 0x5d, 0xda, 0xe9, + 0xf3, 0xa1, 0xba, 0x7b, 0x7e, 0xb7, 0xa6, 0x9a, 0x8f, 0x69, 0x26, 0x19, 0x1c, 0xef, 0x3f, 0x7a, + 0x0e, 0xd9, 0x03, 0x7c, 0xa2, 0x70, 0x7c, 0x46, 0x67, 0xca, 0xfc, 0x83, 0xf7, 0x03, 0xfc, 0x07, + 0x87, 0x4b, 0x02, 0xd6, 0x2d, 0x05, 0x60, 0xdd, 0x12, 0xe1, 0x58, 0xaa, 0xbb, 0x36, 0x36, 0x9b, + 0xee, 0xbe, 0x0c, 0x07, 0xf8, 0xe4, 0x29, 0x93, 0x11, 0x1c, 0x6a, 0xeb, 0xa9, 0x74, 0xb2, 0x90, + 0x2a, 0xfd, 0x6f, 0x09, 0x72, 0xac, 0xe2, 0x71, 0x0e, 0xb5, 0x0f, 0x20, 0x65, 0x5b, 0x47, 0x6c, + 0xa8, 0x65, 0x1f, 0xbc, 0x15, 0x21, 0x62, 0x03, 0x9f, 0x04, 0xe7, 0x38, 0x9a, 0x1d, 0xad, 0x02, + 0xf7, 0x1e, 0x15, 0xca, 0x9d, 0x1c, 0x95, 0x1b, 0x18, 0x97, 0x4c, 0x64, 0xdc, 0x81, 0xe9, 0x5d, + 0xd5, 0xd5, 0xf6, 0x15, 0x9b, 0x17, 0x92, 0xcc, 0x87, 0xc9, 0xbb, 0x39, 0x39, 0x4f, 0xc9, 0xa2, + 0xe8, 0x4e, 0xe9, 0xff, 0x88, 0x5e, 0xef, 0xe0, 0x3f, 0x95, 0x2d, 0xff, 0x7f, 0x25, 0x3e, 0x9e, + 0x44, 0xfd, 0xff, 0xb4, 0x75, 0x80, 0x1f, 0x25, 0xe0, 0x4a, 0x79, 0x1f, 0x6b, 0x07, 0x65, 0xcb, + 0x74, 0x0c, 0xc7, 0x25, 0x1a, 0x8c, 0xb3, 0x17, 0xbc, 0x05, 0x99, 0x23, 0xc3, 0xdd, 0x57, 0x74, + 0x63, 0x6f, 0x8f, 0x5a, 0xbe, 0xb4, 0x9c, 0x26, 0x84, 0x35, 0x63, 0x6f, 0x0f, 0x3d, 0x84, 0x54, + 0xdb, 0xd2, 0x99, 0x93, 0x9d, 0x7f, 0xb0, 0x10, 0x21, 0x9e, 0x16, 0xcd, 0xe9, 0xb6, 0x37, 0x2d, + 0x1d, 0xcb, 0x34, 0x33, 0xba, 0x06, 0xa0, 0x11, 0x6a, 0xc7, 0x32, 0x4c, 0x97, 0xcf, 0xa2, 0x01, + 0x0a, 0xaa, 0x42, 0xc6, 0xc5, 0x76, 0xdb, 0x30, 0x55, 0x17, 0x17, 0xc7, 0xa9, 0xf2, 0x6e, 0x46, + 0x16, 0xbc, 0xd3, 0x32, 0x34, 0x75, 0x0d, 0x3b, 0x9a, 0x6d, 0x74, 0x5c, 0xcb, 0xe6, 0x5a, 0xf4, + 0x99, 0xb9, 0xc5, 0xfd, 0x61, 0x0a, 0x8a, 0xfd, 0x1a, 0x8a, 0xb3, 0x9f, 0x6c, 0xc3, 0x04, 0xc1, + 0xe9, 0x2d, 0x97, 0xf7, 0x94, 0x07, 0x83, 0x14, 0x11, 0x51, 0x02, 0x8a, 0xf7, 0x5b, 0x2e, 0x2f, + 0x3c, 0x97, 0x33, 0xff, 0x7b, 0x12, 0x4c, 0xb0, 0x04, 0x74, 0x1f, 0xd2, 0x7c, 0x61, 0x42, 0xa7, + 0x65, 0x4c, 0xae, 0x5e, 0x3e, 0x3b, 0x5d, 0x98, 0x64, 0x6b, 0x0d, 0x6b, 0x5f, 0xfa, 0x7f, 0xe5, + 0x49, 0x9a, 0xaf, 0xa6, 0x93, 0x36, 0x73, 0x5c, 0xd5, 0x76, 0xe9, 0x22, 0x50, 0x82, 0x61, 0x0e, + 0x4a, 0xd8, 0xc0, 0x27, 0x68, 0x1d, 0x26, 0x1c, 0x57, 0x75, 0xbb, 0x0e, 0x6f, 0xb5, 0x0b, 0x15, + 0xb6, 0x4e, 0x39, 0x65, 0x2e, 0x81, 0x38, 0x43, 0x3a, 0x76, 0x55, 0xa3, 0x45, 0x9b, 0x31, 0x23, + 0xf3, 0xa7, 0xd2, 0x6f, 0x4a, 0x30, 0xc1, 0xb2, 0xa2, 0x2b, 0x30, 0x2b, 0xaf, 0x6c, 0x3d, 0xa9, + 0x28, 0xb5, 0xad, 0xb5, 0x4a, 0xa3, 0x22, 0x6f, 0xd6, 0xb6, 0x56, 0x1a, 0x95, 0xc2, 0x18, 0xba, + 0x0c, 0x48, 0x24, 0x94, 0x9f, 0x6d, 0xd5, 0x6b, 0xf5, 0x46, 0x65, 0xab, 0x51, 0x90, 0xe8, 0x1a, + 0x05, 0xa5, 0x07, 0xa8, 0x09, 0x74, 0x13, 0x16, 0x7b, 0xa9, 0x4a, 0xbd, 0xb1, 0xd2, 0xa8, 0x2b, + 0x95, 0x7a, 0xa3, 0xb6, 0xb9, 0xd2, 0xa8, 0xac, 0x15, 0x92, 0x43, 0x72, 0x91, 0x97, 0xc8, 0x72, + 0xa5, 0xdc, 0x28, 0xa4, 0x4a, 0xaf, 0xe1, 0x92, 0x8c, 0x35, 0xab, 0xdd, 0xe9, 0xba, 0x98, 0x94, + 0xd2, 0x89, 0x73, 0xbc, 0x5c, 0x81, 0x49, 0xdd, 0x3e, 0x51, 0xec, 0xae, 0xc9, 0x47, 0xcb, 0x84, + 0x6e, 0x9f, 0xc8, 0x5d, 0x93, 0x77, 0xc6, 0x7f, 0x24, 0xc1, 0xe5, 0xde, 0x97, 0xc7, 0xd9, 0x15, + 0x9f, 0x43, 0x56, 0xd5, 0x75, 0xac, 0x2b, 0x3a, 0x6e, 0xb9, 0x2a, 0x77, 0x55, 0xee, 0x05, 0x24, + 0xf1, 0x05, 0xbc, 0x25, 0x6f, 0x01, 0x6f, 0xf3, 0x45, 0xb9, 0x4c, 0x0b, 0xb2, 0x46, 0x38, 0x84, + 0x29, 0xa2, 0x42, 0x28, 0xa5, 0xf4, 0xaf, 0x52, 0x30, 0x55, 0x31, 0xf5, 0xc6, 0x71, 0xac, 0xb3, + 0xcb, 0x65, 0x98, 0xd0, 0xac, 0x76, 0xdb, 0x70, 0x85, 0x9a, 0xd8, 0x13, 0xfa, 0xa5, 0x80, 0xa3, + 0x99, 0x1c, 0xc1, 0xd1, 0xf2, 0x5d, 0x4c, 0xf4, 0x7d, 0xb8, 0x42, 0x2c, 0xa8, 0x6d, 0xaa, 0x2d, + 0x85, 0x49, 0x53, 0x5c, 0xdb, 0x68, 0x36, 0xb1, 0xcd, 0x97, 0x0b, 0xef, 0x46, 0x94, 0xb3, 0xc6, + 0x39, 0xca, 0x94, 0xa1, 0xc1, 0xf2, 0xcb, 0x97, 0x8c, 0x28, 0x32, 0xfa, 0x04, 0x80, 0x4c, 0x4e, + 0x74, 0x09, 0xd2, 0xe1, 0xb6, 0x69, 0xd0, 0x1a, 0xa4, 0x30, 0x47, 0x84, 0x81, 0x3c, 0x3b, 0x68, + 0x99, 0x60, 0x8b, 0x57, 0x5d, 0xc3, 0xc6, 0xca, 0xfd, 0x8e, 0x46, 0x17, 0x03, 0xd2, 0xab, 0xf9, + 0xb3, 0xd3, 0x05, 0x90, 0x19, 0xf9, 0xfe, 0x76, 0x99, 0x60, 0x0d, 0xf6, 0xbf, 0xa3, 0xa1, 0x97, + 0xf0, 0x6e, 0x60, 0x4d, 0x83, 0xcc, 0xc5, 0xbc, 0x5a, 0xaa, 0xab, 0xec, 0x1b, 0xcd, 0x7d, 0x6c, + 0x2b, 0xde, 0x12, 0x33, 0x5d, 0x0f, 0x4c, 0xcb, 0x37, 0x7d, 0x86, 0xb2, 0x6a, 0xb2, 0xd2, 0xaf, + 0xb8, 0x55, 0x9a, 0xd9, 0xd3, 0x19, 0x51, 0x7e, 0xc7, 0x32, 0x1c, 0xcb, 0x2c, 0x66, 0x98, 0xf2, + 0xd9, 0x13, 0x7a, 0x0e, 0x05, 0xc3, 0x54, 0xf6, 0x5a, 0x46, 0x73, 0xdf, 0x55, 0x8e, 0x6c, 0xc3, + 0xc5, 0x4e, 0x71, 0x86, 0xd6, 0x32, 0xaa, 0x33, 0xd6, 0xf9, 0x92, 0xaf, 0xfe, 0x92, 0xe4, 0xe4, + 0xf5, 0xcd, 0x1b, 0xe6, 0x63, 0xca, 0x4f, 0x89, 0x8e, 0x37, 0x65, 0x4f, 0x16, 0xd2, 0xa5, 0xff, + 0x24, 0x41, 0x5e, 0xf4, 0xa4, 0x38, 0x3b, 0xfd, 0x5d, 0x28, 0x58, 0x26, 0x56, 0x3a, 0xfb, 0xaa, + 0x83, 0xb9, 0x8a, 0xf8, 0xbc, 0x92, 0xb7, 0x4c, 0xbc, 0x4d, 0xc8, 0x4c, 0x13, 0x68, 0x1b, 0x66, + 0x1c, 0x57, 0x6d, 0x1a, 0x66, 0x33, 0xa0, 0xb9, 0xf1, 0xd1, 0xfd, 0xf9, 0x02, 0xe7, 0xf6, 0xe8, + 0x21, 0x67, 0xe4, 0x8f, 0x24, 0x98, 0x59, 0xd1, 0xdb, 0x86, 0x59, 0xef, 0xb4, 0x8c, 0x58, 0x97, + 0x0f, 0x6e, 0x42, 0xc6, 0x21, 0x32, 0x7d, 0x8b, 0xee, 0x43, 0xbf, 0x34, 0x4d, 0x21, 0xa6, 0xfd, + 0x29, 0x4c, 0xe3, 0xe3, 0x8e, 0x61, 0xab, 0xae, 0x61, 0x99, 0x0c, 0xab, 0xa4, 0x46, 0xaf, 0x5b, + 0xde, 0xe7, 0xf5, 0xf1, 0x0a, 0xaf, 0xd9, 0x67, 0x80, 0x82, 0x15, 0x8b, 0x13, 0xb4, 0x28, 0x30, + 0x4b, 0x45, 0xef, 0x98, 0x4e, 0xcc, 0x5a, 0xe3, 0x26, 0xf7, 0x57, 0x61, 0x2e, 0xfc, 0x82, 0x38, + 0x4b, 0xff, 0x3d, 0xde, 0xe2, 0x9b, 0xd8, 0x6e, 0x7e, 0x05, 0x0b, 0x28, 0x42, 0xef, 0x5c, 0x7c, + 0x9c, 0x25, 0xff, 0x0d, 0x09, 0xae, 0x52, 0xd9, 0x74, 0xab, 0x65, 0x0f, 0xdb, 0x4f, 0xb1, 0xea, + 0xc4, 0x0a, 0x9b, 0x6f, 0xc0, 0x04, 0x83, 0xbf, 0xb4, 0xc7, 0x8e, 0xaf, 0x66, 0x89, 0xb3, 0x52, + 0x77, 0x2d, 0x9b, 0x38, 0x2b, 0x3c, 0x89, 0xd7, 0x53, 0x85, 0xf9, 0xa8, 0xb2, 0xc4, 0xbc, 0x3e, + 0x30, 0xc3, 0x7d, 0x46, 0xd2, 0xc5, 0xcb, 0xfb, 0xc4, 0x59, 0x42, 0x15, 0xc8, 0x6a, 0xf4, 0x9f, + 0xe2, 0x9e, 0x74, 0x30, 0x95, 0x9f, 0x1f, 0xe6, 0x6e, 0x32, 0xb6, 0xc6, 0x49, 0x07, 0x13, 0x9f, + 0x55, 0xfc, 0x27, 0xea, 0x0a, 0x54, 0x75, 0xa8, 0xc3, 0x4a, 0xc7, 0x17, 0xcd, 0x2b, 0x7c, 0xbe, + 0x90, 0x26, 0xfe, 0x71, 0x92, 0xab, 0x82, 0xbd, 0x89, 0x33, 0xc5, 0xea, 0xa2, 0x7c, 0x1e, 0xda, + 0xf5, 0x0a, 0x56, 0x3f, 0x71, 0x81, 0xea, 0x07, 0x96, 0xdb, 0x7d, 0x2a, 0xfa, 0x0c, 0x02, 0x0b, + 0xea, 0x0a, 0xab, 0x99, 0x80, 0x40, 0x17, 0x51, 0xca, 0x8c, 0x2f, 0x85, 0xd1, 0x1d, 0x54, 0x86, + 0x34, 0x3e, 0xee, 0x28, 0x3a, 0x76, 0x34, 0x6e, 0xd6, 0x4a, 0x83, 0xb6, 0xe7, 0xfa, 0x40, 0xc1, + 0x24, 0x3e, 0xee, 0x10, 0x22, 0xda, 0x21, 0x33, 0x9c, 0xf0, 0x11, 0x68, 0xb1, 0x9d, 0xf3, 0x31, + 0x86, 0xdf, 0x5f, 0xb8, 0xb8, 0x69, 0xcf, 0x3d, 0x60, 0x22, 0x78, 0xdb, 0x7d, 0x21, 0xc1, 0x5b, + 0x91, 0x6d, 0x17, 0xe7, 0x64, 0xf7, 0x09, 0xa4, 0xa8, 0x0a, 0x12, 0x17, 0x54, 0x01, 0xe5, 0x2a, + 0xfd, 0xae, 0x18, 0xf5, 0x32, 0x6e, 0x59, 0x44, 0xbd, 0x5f, 0xc1, 0x62, 0xd9, 0xa4, 0x68, 0xf6, + 0xc4, 0x85, 0x9b, 0x5d, 0xb0, 0xf6, 0x98, 0x85, 0x9e, 0xc2, 0xc6, 0x69, 0x16, 0xfe, 0xa6, 0x04, + 0xb3, 0x55, 0xac, 0xda, 0xee, 0x2e, 0x56, 0xdd, 0x98, 0x7d, 0xdc, 0x0f, 0x20, 0x69, 0x5a, 0x47, + 0x17, 0x59, 0x2f, 0x24, 0xf9, 0xfd, 0x69, 0x2b, 0x5c, 0xae, 0x38, 0x6b, 0xfd, 0xaf, 0x13, 0x90, + 0x79, 0x52, 0x8e, 0xb3, 0xae, 0x9f, 0xf0, 0x75, 0x69, 0x36, 0xd4, 0xa3, 0xba, 0xa5, 0xf7, 0xbe, + 0xa5, 0x27, 0xe5, 0x0d, 0x7c, 0x22, 0xba, 0x25, 0xe1, 0x42, 0x2b, 0x90, 0x71, 0xf7, 0x6d, 0xec, + 0xec, 0x5b, 0x2d, 0xfd, 0x22, 0x3e, 0x8b, 0xcf, 0x35, 0x7f, 0x00, 0xe3, 0x54, 0xae, 0x88, 0x8d, + 0x90, 0x22, 0x62, 0x23, 0xc8, 0x6b, 0x3c, 0xb7, 0x2f, 0x71, 0x91, 0xd7, 0x08, 0x02, 0x6b, 0x1c, + 0xcf, 0x37, 0x1a, 0x2f, 0x4c, 0x94, 0x9e, 0x03, 0x90, 0xaa, 0xc5, 0xd9, 0x3c, 0x7f, 0x35, 0x09, + 0xf9, 0xed, 0xae, 0xb3, 0x1f, 0x73, 0x7f, 0x2c, 0x03, 0x74, 0xba, 0x0e, 0x85, 0x0d, 0xc7, 0x26, + 0xaf, 0xff, 0x39, 0xc1, 0x17, 0x42, 0x01, 0x8c, 0xaf, 0x71, 0x6c, 0xa2, 0x2a, 0x17, 0x82, 0x15, + 0x3f, 0x82, 0xe3, 0xc6, 0x30, 0x80, 0xd9, 0x38, 0x36, 0x37, 0xb1, 0x87, 0x2c, 0x99, 0x24, 0x4c, + 0x24, 0x7d, 0x02, 0x93, 0xe4, 0x41, 0x71, 0xad, 0x8b, 0x34, 0xf9, 0x04, 0xe1, 0x69, 0x58, 0xe8, + 0x11, 0x64, 0x18, 0x37, 0x99, 0xb8, 0x26, 0xe8, 0xc4, 0x15, 0x55, 0x17, 0xae, 0x46, 0x3a, 0x65, + 0xa5, 0x29, 0x2b, 0x99, 0xa6, 0xe6, 0x60, 0x7c, 0xcf, 0xb2, 0x35, 0x4c, 0xc3, 0x32, 0xd2, 0x32, + 0x7b, 0x08, 0xb6, 0xea, 0x7a, 0x2a, 0x9d, 0x2e, 0x64, 0xd6, 0x53, 0xe9, 0x4c, 0x01, 0x4a, 0xbf, + 0x29, 0xc1, 0xb4, 0xd7, 0x1c, 0x71, 0xda, 0xf2, 0x72, 0x48, 0x97, 0x17, 0x6f, 0x10, 0xa2, 0xc6, + 0xd2, 0xbf, 0xa1, 0x8e, 0x8d, 0x66, 0x1d, 0xd2, 0xf6, 0x89, 0xb3, 0xbf, 0x3c, 0x62, 0x51, 0x3a, + 0x89, 0x8b, 0xb6, 0x31, 0x0d, 0xd8, 0xb9, 0x0f, 0x73, 0x46, 0x9b, 0x58, 0x79, 0xc3, 0x6d, 0x9d, + 0x70, 0x54, 0xe6, 0x62, 0xb1, 0xf1, 0x3b, 0xeb, 0xa7, 0x95, 0x45, 0x12, 0x37, 0x7c, 0x6c, 0x23, + 0xc7, 0xaf, 0x4f, 0x9c, 0x0a, 0xaf, 0xc1, 0x94, 0xcd, 0x44, 0x13, 0xef, 0xe4, 0x82, 0x3a, 0xcf, + 0x79, 0xac, 0x44, 0xed, 0xbf, 0x93, 0x80, 0xe9, 0xe7, 0x5d, 0x6c, 0x9f, 0x7c, 0x9d, 0x94, 0x7e, + 0x1b, 0xa6, 0x8f, 0x54, 0xc3, 0x55, 0xf6, 0x2c, 0x5b, 0xe9, 0x76, 0x74, 0xd5, 0x15, 0xa1, 0x22, + 0x53, 0x84, 0xfc, 0xd8, 0xb2, 0x77, 0x28, 0x11, 0x61, 0x40, 0x07, 0xa6, 0x75, 0x64, 0x2a, 0x84, + 0x4c, 0xd1, 0xf0, 0xb1, 0xc9, 0x57, 0x98, 0x57, 0x3f, 0xfc, 0x8f, 0xa7, 0x0b, 0x0f, 0x47, 0x0a, + 0x06, 0xa3, 0xe1, 0x6c, 0xdd, 0xae, 0xa1, 0x2f, 0xed, 0xec, 0xd4, 0xd6, 0xe4, 0x02, 0x15, 0xf9, + 0x92, 0x49, 0x6c, 0x1c, 0x9b, 0x62, 0x16, 0xff, 0xfb, 0x09, 0x28, 0xf8, 0x9a, 0x8a, 0xb3, 0x39, + 0x2b, 0x90, 0x7d, 0xd5, 0xc5, 0xb6, 0xf1, 0x06, 0x8d, 0x09, 0x9c, 0x91, 0x18, 0xa2, 0xcf, 0x21, + 0x17, 0xd2, 0x43, 0xf2, 0x17, 0xd3, 0x43, 0xf6, 0xc8, 0x57, 0x01, 0xba, 0x07, 0x33, 0xee, 0xb1, + 0xa9, 0xb0, 0x60, 0x3f, 0x16, 0x2e, 0x22, 0x62, 0x1b, 0xa6, 0x5d, 0xa2, 0x0f, 0x42, 0xa7, 0xa1, + 0x22, 0x4e, 0xe9, 0x5f, 0x4a, 0x80, 0xa8, 0xa2, 0x6a, 0x6c, 0x23, 0xe0, 0xeb, 0xd2, 0xab, 0xee, + 0x42, 0x81, 0x06, 0x4d, 0x2a, 0xc6, 0x9e, 0xd2, 0x36, 0x1c, 0xc7, 0x30, 0x9b, 0xbc, 0x5b, 0xe5, + 0x29, 0xbd, 0xb6, 0xb7, 0xc9, 0xa8, 0xbc, 0xc1, 0xff, 0x1c, 0xcc, 0x86, 0xaa, 0x11, 0x67, 0x93, + 0x5f, 0x87, 0xdc, 0x9e, 0xd5, 0x35, 0x75, 0x85, 0x6d, 0x96, 0xf0, 0xd5, 0xc3, 0x2c, 0xa5, 0xb1, + 0xf7, 0x95, 0xfe, 0x47, 0x02, 0xe6, 0x64, 0xec, 0x58, 0xad, 0x43, 0x1c, 0xbf, 0x22, 0xab, 0xc0, + 0xb7, 0x69, 0x94, 0x37, 0xd2, 0x67, 0x86, 0x31, 0xb3, 0xe9, 0x2f, 0xbc, 0x10, 0x7f, 0x73, 0x78, + 0xbf, 0xed, 0x5f, 0x7a, 0xe7, 0x4b, 0x78, 0xa9, 0xd0, 0x12, 0x9e, 0x05, 0xd3, 0x46, 0xd3, 0xb4, + 0x88, 0x7d, 0x73, 0xf0, 0x2b, 0xb3, 0xdb, 0x16, 0xf8, 0x66, 0x69, 0x58, 0x21, 0x6b, 0x8c, 0xa5, + 0x8e, 0x5f, 0x6d, 0x75, 0xdb, 0xd4, 0xcb, 0x5e, 0xbd, 0x4c, 0xca, 0x7b, 0x76, 0xba, 0x90, 0x0f, + 0xa5, 0x39, 0x72, 0xde, 0xf0, 0x9e, 0x89, 0x74, 0xde, 0xe4, 0xdf, 0x85, 0x4b, 0x3d, 0x2a, 0x8f, + 0xd3, 0x1f, 0xfa, 0x17, 0x49, 0xb8, 0x1a, 0x16, 0x1f, 0x37, 0x6a, 0xf9, 0xba, 0x37, 0x6b, 0x15, + 0xa6, 0xda, 0x86, 0xf9, 0x66, 0x8b, 0x96, 0xb9, 0xb6, 0x61, 0xfa, 0x6b, 0xbf, 0x11, 0x1d, 0x64, + 0xe2, 0xff, 0x43, 0x07, 0x51, 0x61, 0x3e, 0xaa, 0x05, 0xe3, 0xec, 0x25, 0x3f, 0x94, 0x20, 0x17, + 0xf7, 0x3a, 0xdc, 0x9b, 0x85, 0xb9, 0xf1, 0x3a, 0x37, 0x60, 0xea, 0x2b, 0x58, 0xb8, 0xfb, 0x1d, + 0x09, 0x50, 0xc3, 0xee, 0x9a, 0x04, 0x10, 0x3f, 0xb5, 0x9a, 0x71, 0x56, 0x76, 0x0e, 0xc6, 0x0d, + 0x53, 0xc7, 0xc7, 0xb4, 0xb2, 0x29, 0x99, 0x3d, 0x84, 0x76, 0x20, 0x93, 0x23, 0xed, 0x40, 0xfa, + 0xb1, 0x2e, 0xa1, 0x82, 0xc6, 0xa9, 0x85, 0x7f, 0x98, 0x80, 0x59, 0x5e, 0x9d, 0xd8, 0x17, 0x2e, + 0xbf, 0x05, 0xe3, 0x2d, 0x22, 0x73, 0x48, 0x9b, 0xd3, 0x77, 0x8a, 0x36, 0xa7, 0x99, 0xd1, 0x2f, + 0x03, 0x74, 0x6c, 0x7c, 0xa8, 0x30, 0xd6, 0xe4, 0x48, 0xac, 0x19, 0xc2, 0x41, 0x09, 0xe8, 0x3b, + 0x30, 0x4d, 0x46, 0x78, 0xc7, 0xb6, 0x3a, 0x96, 0x43, 0x1c, 0x1a, 0x67, 0x34, 0x54, 0x34, 0x73, + 0x76, 0xba, 0x30, 0xb5, 0x69, 0x98, 0xdb, 0x9c, 0xb1, 0x51, 0x97, 0x89, 0xa9, 0xf0, 0x1e, 0xc5, + 0x00, 0xfc, 0xf7, 0x12, 0xcc, 0x7d, 0x65, 0x4b, 0xbd, 0x7f, 0x12, 0x1a, 0xf3, 0x66, 0x9e, 0x02, + 0x7d, 0xac, 0x99, 0x7b, 0x56, 0xfc, 0x0b, 0xf0, 0x3f, 0x94, 0x60, 0x26, 0x20, 0x3e, 0x4e, 0x4f, + 0xe6, 0x8d, 0x74, 0x56, 0xfa, 0x55, 0xe2, 0xdb, 0x04, 0xbb, 0x7d, 0x9c, 0x83, 0xea, 0x9f, 0x26, + 0xe0, 0x72, 0x99, 0xed, 0x4d, 0x8b, 0xc0, 0x8d, 0x38, 0x7b, 0x49, 0x11, 0x26, 0x0f, 0xb1, 0xed, + 0x18, 0x16, 0x9b, 0x61, 0xa7, 0x64, 0xf1, 0x88, 0xe6, 0x21, 0xed, 0x98, 0x6a, 0xc7, 0xd9, 0xb7, + 0xc4, 0xce, 0x9d, 0xf7, 0xec, 0x05, 0x99, 0x8c, 0xbf, 0x79, 0x90, 0xc9, 0xc4, 0xf0, 0x20, 0x93, + 0xc9, 0x5f, 0x38, 0xc8, 0x84, 0x6f, 0x93, 0xfd, 0x81, 0x04, 0x57, 0xfa, 0xf4, 0x17, 0x67, 0x9f, + 0xf9, 0x01, 0x64, 0x35, 0x2e, 0x98, 0x58, 0x63, 0xb6, 0x13, 0x58, 0x23, 0xd9, 0xde, 0x10, 0xac, + 0x9c, 0x9d, 0x2e, 0x80, 0x28, 0x6a, 0x6d, 0x8d, 0xab, 0x88, 0xfc, 0xd7, 0x4b, 0xff, 0x21, 0x07, + 0xd3, 0x95, 0x63, 0xb6, 0xce, 0x5d, 0x67, 0xfe, 0x00, 0x7a, 0x0c, 0xe9, 0x8e, 0x6d, 0x1d, 0x1a, + 0xa2, 0x1a, 0xf9, 0x50, 0x6c, 0x81, 0xa8, 0x46, 0x0f, 0xd7, 0x36, 0xe7, 0x90, 0x3d, 0x5e, 0xd4, + 0x80, 0xcc, 0x53, 0x4b, 0x53, 0x5b, 0x8f, 0x8d, 0x96, 0xe8, 0xff, 0xef, 0x9f, 0x2f, 0x68, 0xc9, + 0xe3, 0xd9, 0x56, 0xdd, 0x7d, 0xd1, 0x14, 0x1e, 0x11, 0xd5, 0x20, 0x5d, 0x75, 0xdd, 0x0e, 0x49, + 0xe4, 0xd6, 0xe4, 0xce, 0x08, 0x42, 0x09, 0x8b, 0x08, 0x57, 0x15, 0xec, 0xa8, 0x01, 0x33, 0x4f, + 0x2c, 0xab, 0xd9, 0xc2, 0xe5, 0x96, 0xd5, 0xd5, 0xcb, 0x96, 0xb9, 0x67, 0x34, 0xb9, 0x3d, 0xbe, + 0x3d, 0x82, 0xcc, 0x27, 0xe5, 0xba, 0xdc, 0x2f, 0x00, 0xad, 0x40, 0xba, 0xfe, 0x90, 0x0b, 0x63, + 0x0e, 0xdc, 0xad, 0x11, 0x84, 0xd5, 0x1f, 0xca, 0x1e, 0x1b, 0x5a, 0x87, 0xec, 0xca, 0xeb, 0xae, + 0x8d, 0xb9, 0x94, 0x89, 0x81, 0x81, 0x0d, 0xbd, 0x52, 0x28, 0x97, 0x1c, 0x64, 0x46, 0x75, 0xc8, + 0xbf, 0xb4, 0xec, 0x83, 0x96, 0xa5, 0x8a, 0x1a, 0x4e, 0x52, 0x71, 0xdf, 0x18, 0x41, 0x9c, 0x60, + 0x94, 0x7b, 0x44, 0xa0, 0xef, 0xc2, 0x34, 0x69, 0x8c, 0x86, 0xba, 0xdb, 0x12, 0x85, 0x4c, 0x53, + 0xa9, 0xdf, 0x1c, 0x41, 0xaa, 0xc7, 0x29, 0x36, 0x5a, 0x7a, 0x44, 0xcd, 0x7f, 0x07, 0xa6, 0x42, + 0x9d, 0x00, 0x21, 0x48, 0x75, 0x48, 0x7b, 0x4b, 0x34, 0x00, 0x89, 0xfe, 0x47, 0xef, 0xc1, 0xa4, + 0x69, 0xe9, 0x58, 0x8c, 0x90, 0xa9, 0xd5, 0xb9, 0xb3, 0xd3, 0x85, 0x89, 0x2d, 0x4b, 0x67, 0xee, + 0x0a, 0xff, 0x27, 0x4f, 0x90, 0x4c, 0xc2, 0x59, 0x99, 0xbf, 0x0d, 0x29, 0xd2, 0xfa, 0xc4, 0x48, + 0xed, 0xaa, 0x0e, 0xde, 0xb1, 0x0d, 0x2e, 0x53, 0x3c, 0xf2, 0x7c, 0x3f, 0x93, 0x20, 0x51, 0x7f, + 0x48, 0x1c, 0xf5, 0xdd, 0xae, 0x76, 0x80, 0x5d, 0x9e, 0x8b, 0x3f, 0x51, 0x07, 0xde, 0xc6, 0x7b, + 0x06, 0xf3, 0xa1, 0x32, 0x32, 0x7f, 0x42, 0xef, 0x00, 0xa8, 0x9a, 0x86, 0x1d, 0x47, 0x11, 0x07, + 0xf7, 0x32, 0x72, 0x86, 0x51, 0x36, 0xf0, 0x09, 0x61, 0x73, 0xb0, 0x66, 0x63, 0x57, 0x44, 0x52, + 0xb1, 0x27, 0xc2, 0xe6, 0xe2, 0x76, 0x47, 0x71, 0xad, 0x03, 0x6c, 0xd2, 0x3e, 0x93, 0x21, 0xc6, + 0xa7, 0xdd, 0x69, 0x10, 0x02, 0xb1, 0x9b, 0xd8, 0xd4, 0x7d, 0x23, 0x97, 0x91, 0xbd, 0x67, 0x22, + 0xd2, 0xc6, 0x4d, 0x83, 0x9f, 0x3d, 0xcb, 0xc8, 0xfc, 0x89, 0x68, 0x4c, 0xed, 0xba, 0xfb, 0xb4, + 0x55, 0x32, 0x32, 0xfd, 0xcf, 0xab, 0xf6, 0xb7, 0x25, 0x48, 0x3e, 0x29, 0xd7, 0x2f, 0x5c, 0x37, + 0x21, 0x31, 0xe9, 0x4b, 0xa4, 0x01, 0x8c, 0x46, 0xab, 0x65, 0x98, 0x4d, 0xe2, 0xd2, 0xfc, 0x00, + 0x6b, 0xa2, 0x66, 0x79, 0x4e, 0xde, 0x66, 0x54, 0xb4, 0x08, 0x59, 0xcd, 0xc6, 0x3a, 0x36, 0x5d, + 0x43, 0x6d, 0x39, 0xbc, 0x8a, 0x41, 0x12, 0x2f, 0xdc, 0xaf, 0x4b, 0x30, 0x4e, 0x3b, 0x2f, 0x7a, + 0x1b, 0x32, 0x9a, 0x65, 0xba, 0xaa, 0x61, 0x72, 0x2b, 0x94, 0x91, 0x7d, 0xc2, 0xc0, 0x42, 0x5e, + 0x87, 0x9c, 0xaa, 0x69, 0x56, 0xd7, 0x74, 0x15, 0x53, 0x6d, 0x63, 0x5e, 0xd8, 0x2c, 0xa7, 0x6d, + 0xa9, 0x6d, 0x8c, 0x16, 0x40, 0x3c, 0x7a, 0xc7, 0x27, 0x33, 0x32, 0x70, 0xd2, 0x06, 0x3e, 0xe1, + 0x25, 0xf9, 0x03, 0x09, 0xd2, 0xa2, 0xd3, 0x93, 0xc2, 0x34, 0xb1, 0x89, 0x6d, 0xd5, 0xb5, 0xbc, + 0xc2, 0x78, 0x84, 0xde, 0x19, 0x2f, 0xe3, 0xcf, 0x78, 0x73, 0x30, 0xee, 0x92, 0x7e, 0xcd, 0xcb, + 0xc1, 0x1e, 0xe8, 0xba, 0x74, 0x4b, 0x6d, 0xb2, 0xa5, 0xb8, 0x8c, 0xcc, 0x1e, 0x48, 0x95, 0x78, + 0x10, 0x2e, 0xd3, 0x0e, 0x7f, 0x22, 0xe5, 0x65, 0x41, 0xa2, 0xbb, 0xb8, 0x69, 0x98, 0xb4, 0x03, + 0x24, 0x65, 0xa0, 0xa4, 0x55, 0x42, 0x41, 0x6f, 0x41, 0x86, 0x65, 0xc0, 0xa6, 0x4e, 0x7b, 0x41, + 0x52, 0x4e, 0x53, 0x42, 0x45, 0x9c, 0x0f, 0x9b, 0x3f, 0x80, 0x8c, 0x37, 0xc6, 0x48, 0x43, 0x76, + 0x1d, 0x4f, 0xa9, 0xf4, 0x3f, 0x7a, 0x1f, 0xe6, 0x5e, 0x75, 0xd5, 0x96, 0xb1, 0x47, 0x57, 0xd9, + 0x48, 0x36, 0xa6, 0x3f, 0x56, 0x1f, 0xe4, 0xa5, 0x51, 0x09, 0x54, 0x8d, 0x62, 0x48, 0x26, 0xfd, + 0x21, 0x19, 0xdc, 0x36, 0x29, 0xfd, 0x58, 0x82, 0x19, 0x16, 0x32, 0xc4, 0x42, 0x59, 0xe3, 0x73, + 0x30, 0x3e, 0x86, 0x8c, 0xae, 0xba, 0x2a, 0x3b, 0x22, 0x9a, 0x18, 0x7a, 0x44, 0xd4, 0x3b, 0xa0, + 0xa0, 0xba, 0x2a, 0x3d, 0x26, 0x8a, 0x20, 0x45, 0xfe, 0xb3, 0x33, 0xb5, 0x32, 0xfd, 0xef, 0x07, + 0x61, 0x04, 0x8b, 0x1b, 0xa7, 0xc3, 0xb5, 0x0c, 0x97, 0x88, 0xf6, 0x2b, 0xa6, 0x66, 0x9f, 0x74, + 0x5c, 0xc3, 0x32, 0x9f, 0xd1, 0x5f, 0x07, 0x15, 0x02, 0x9b, 0x58, 0x74, 0xef, 0x8a, 0x97, 0xe5, + 0xf7, 0x27, 0x60, 0xaa, 0x72, 0xdc, 0xb1, 0xec, 0x58, 0x17, 0xb5, 0x56, 0x61, 0x92, 0x23, 0xfe, + 0x21, 0xdb, 0xca, 0x3d, 0xb6, 0x5a, 0xec, 0xd8, 0x72, 0x46, 0xb4, 0x0a, 0xc0, 0x82, 0x4e, 0x69, + 0xdc, 0x51, 0xf2, 0x02, 0x9b, 0x6b, 0x94, 0x8d, 0x50, 0xd1, 0x16, 0x64, 0xdb, 0x87, 0x9a, 0xa6, + 0xec, 0x19, 0x2d, 0x97, 0x47, 0xed, 0x45, 0x87, 0x9c, 0x6f, 0xbe, 0x28, 0x97, 0x1f, 0xd3, 0x4c, + 0x2c, 0x80, 0xce, 0x7f, 0x96, 0x81, 0x48, 0x60, 0xff, 0xd1, 0x37, 0x81, 0x1f, 0xdd, 0x51, 0x1c, + 0x71, 0x4a, 0x6f, 0x75, 0xea, 0xec, 0x74, 0x21, 0x23, 0x53, 0x6a, 0xbd, 0xde, 0x90, 0x33, 0x2c, + 0x43, 0xdd, 0x71, 0xd1, 0x0d, 0x98, 0xb2, 0xda, 0x86, 0xab, 0x08, 0x1f, 0x88, 0xbb, 0x8d, 0x39, + 0x42, 0x14, 0x3e, 0x12, 0x6a, 0xc0, 0x1d, 0x6c, 0xd2, 0x51, 0x40, 0xea, 0xa9, 0xec, 0xb2, 0xb5, + 0x48, 0x97, 0x8d, 0x77, 0xc5, 0xea, 0xb8, 0x46, 0xdb, 0x78, 0x4d, 0x37, 0xb6, 0xf9, 0xde, 0xd2, + 0x0d, 0x96, 0x9d, 0xd4, 0x6f, 0x95, 0x2e, 0x52, 0xf2, 0xbc, 0xcf, 0x02, 0x59, 0xd1, 0xaf, 0x4b, + 0x70, 0x99, 0x2b, 0x52, 0xd9, 0xa5, 0x31, 0xf3, 0x6a, 0xcb, 0x70, 0x4f, 0x94, 0x83, 0xc3, 0x62, + 0x9a, 0x3a, 0xa7, 0xbf, 0x14, 0xd9, 0x20, 0x81, 0x7e, 0xb0, 0x24, 0x9a, 0xe5, 0xe4, 0x29, 0x67, + 0xde, 0x38, 0xac, 0x98, 0xae, 0x7d, 0xb2, 0x7a, 0xe5, 0xec, 0x74, 0x61, 0xb6, 0x3f, 0xf5, 0x85, + 0x3c, 0xeb, 0xf4, 0xb3, 0xa0, 0x2a, 0x00, 0xf6, 0x7a, 0x23, 0x0d, 0x0f, 0x8c, 0x76, 0x2f, 0x22, + 0xbb, 0xad, 0x1c, 0xe0, 0x45, 0x77, 0xa1, 0xc0, 0x4f, 0xcd, 0xec, 0x19, 0x2d, 0xac, 0x38, 0xc6, + 0x6b, 0x5c, 0x04, 0x6a, 0x83, 0xf2, 0x8c, 0x4e, 0x44, 0xd4, 0x8d, 0xd7, 0x78, 0xfe, 0x07, 0x50, + 0x1c, 0x54, 0xfa, 0xe0, 0x40, 0xc8, 0xb0, 0x4d, 0xdc, 0x8f, 0xc2, 0x2b, 0x32, 0x23, 0x74, 0x55, + 0xb1, 0x2a, 0x93, 0xf8, 0x48, 0x98, 0xa0, 0xdf, 0x4d, 0xc0, 0xd4, 0x6a, 0xb7, 0x75, 0xf0, 0xac, + 0x53, 0xef, 0xb6, 0xdb, 0xaa, 0x7d, 0x42, 0x4c, 0x25, 0x33, 0x1d, 0xa4, 0x98, 0x12, 0x33, 0x95, + 0xd4, 0x36, 0x18, 0xaf, 0x31, 0x99, 0xcc, 0x82, 0xe7, 0xc4, 0xd9, 0x99, 0x00, 0x5a, 0x93, 0xc0, + 0xe1, 0x6f, 0xeb, 0xc8, 0x41, 0x1f, 0x41, 0x31, 0x90, 0x91, 0x2e, 0x9f, 0x28, 0xd8, 0x74, 0x6d, + 0x03, 0xb3, 0xe5, 0xc0, 0xa4, 0x1c, 0x08, 0xbd, 0xa9, 0x91, 0xe4, 0x0a, 0x4b, 0x45, 0x0d, 0xc8, + 0x91, 0x8c, 0x27, 0x0a, 0x9d, 0x6c, 0xc4, 0xa2, 0xed, 0xfd, 0x88, 0xca, 0x85, 0xca, 0xbd, 0x44, + 0xb5, 0x54, 0xa6, 0x3c, 0xf4, 0xaf, 0x9c, 0xc5, 0x3e, 0x65, 0xfe, 0x53, 0x28, 0xf4, 0x66, 0x08, + 0x6a, 0x34, 0xc5, 0x34, 0x3a, 0x17, 0xd4, 0x68, 0x32, 0xa0, 0xad, 0xf5, 0x54, 0x3a, 0x55, 0x18, + 0x2f, 0xfd, 0x71, 0x12, 0xf2, 0xa2, 0xb3, 0xc5, 0x89, 0x66, 0x56, 0x61, 0x9c, 0x74, 0x0d, 0x11, + 0x28, 0x72, 0x7b, 0x48, 0x1f, 0xe7, 0xf1, 0xe7, 0xa4, 0xcb, 0x08, 0x3c, 0x4c, 0x59, 0xe3, 0x30, + 0x3b, 0xf3, 0x7f, 0x3e, 0x01, 0x29, 0x0a, 0x20, 0xee, 0x43, 0x8a, 0x4e, 0x1d, 0xd2, 0x28, 0x53, + 0x07, 0xcd, 0xea, 0x4d, 0x76, 0x89, 0x80, 0xff, 0x49, 0x9c, 0xb9, 0x7d, 0xf5, 0x83, 0xfb, 0x0f, + 0xa8, 0xc9, 0xc9, 0xc9, 0xfc, 0x09, 0xad, 0xd2, 0x08, 0x26, 0xcb, 0x76, 0xb1, 0xce, 0x1d, 0xf7, + 0xc5, 0xf3, 0xda, 0x57, 0x4c, 0x53, 0x82, 0x0f, 0x5d, 0x85, 0x24, 0xb1, 0x65, 0x93, 0x2c, 0xba, + 0xe1, 0xec, 0x74, 0x21, 0x49, 0xac, 0x18, 0xa1, 0xa1, 0x65, 0xc8, 0x86, 0x0d, 0x87, 0x74, 0x37, + 0xc3, 0xcc, 0x63, 0x60, 0xd0, 0x43, 0xcb, 0x1b, 0x60, 0x0c, 0xb4, 0xf2, 0x36, 0xfe, 0xb5, 0x71, + 0x98, 0xaa, 0xb5, 0xe3, 0x9e, 0x58, 0x56, 0xc2, 0x2d, 0x1c, 0x85, 0x76, 0x42, 0x2f, 0x8d, 0x68, + 0xe0, 0xd0, 0x9c, 0x9e, 0xbc, 0xd8, 0x9c, 0x5e, 0x23, 0x2e, 0x30, 0xbf, 0xf8, 0x21, 0x39, 0x00, + 0xd8, 0x84, 0xdf, 0x4f, 0xbd, 0x18, 0x99, 0xf0, 0xf8, 0x27, 0x32, 0x68, 0x84, 0xca, 0xa7, 0xd4, + 0xd3, 0x66, 0xbd, 0x6c, 0x62, 0xf4, 0x5e, 0x36, 0x89, 0x4d, 0x9d, 0x4e, 0x6d, 0x61, 0xbb, 0x3a, + 0xf9, 0xe6, 0x76, 0x75, 0xfe, 0x35, 0xef, 0xac, 0x1f, 0x43, 0x52, 0x37, 0x44, 0xe3, 0x8c, 0x3e, + 0x61, 0x13, 0xa6, 0x73, 0x7a, 0x6d, 0x2a, 0xd8, 0x6b, 0x83, 0x0b, 0x1c, 0xf3, 0xcf, 0x00, 0x7c, + 0x0d, 0xa1, 0x45, 0x98, 0xb0, 0x5a, 0xba, 0x38, 0x98, 0x32, 0xb5, 0x9a, 0x39, 0x3b, 0x5d, 0x18, + 0x7f, 0xd6, 0xd2, 0x6b, 0x6b, 0xf2, 0xb8, 0xd5, 0xd2, 0x6b, 0x3a, 0xbd, 0x7b, 0x03, 0x1f, 0x29, + 0x5e, 0xc0, 0x5a, 0x4e, 0x9e, 0x34, 0xf1, 0xd1, 0x1a, 0x76, 0xb4, 0x9e, 0x40, 0x1a, 0xd2, 0x05, + 0x7f, 0x24, 0x41, 0x5e, 0xb4, 0x46, 0xbc, 0x66, 0x26, 0x6d, 0xb4, 0xf9, 0xb0, 0x4b, 0x5e, 0x6c, + 0xd8, 0x09, 0x3e, 0x7e, 0xb0, 0xf7, 0x37, 0x24, 0x1e, 0xac, 0x5c, 0xd7, 0x54, 0x97, 0x38, 0x1b, + 0x31, 0x0e, 0x95, 0x77, 0xa1, 0x60, 0xab, 0xa6, 0x6e, 0xb5, 0x8d, 0xd7, 0x98, 0xad, 0x88, 0x3a, + 0x7c, 0x73, 0x73, 0xda, 0xa3, 0xd3, 0x25, 0x3f, 0xb1, 0xa0, 0xfb, 0xfb, 0x09, 0x1e, 0xd8, 0xec, + 0x15, 0x26, 0x4e, 0xa5, 0x7d, 0x1f, 0x66, 0x7a, 0xaf, 0x46, 0x11, 0xa3, 0xf8, 0xbd, 0x08, 0x79, + 0x51, 0x05, 0x61, 0x81, 0x88, 0x22, 0x72, 0xbe, 0xe7, 0x9a, 0x14, 0x07, 0x95, 0x21, 0x1b, 0xbc, + 0x71, 0x25, 0x39, 0xf2, 0x8d, 0x2b, 0x60, 0x7b, 0xf7, 0xac, 0xcc, 0xff, 0x0a, 0x8c, 0xd3, 0xe4, + 0x37, 0x30, 0xdd, 0xbc, 0x4d, 0xff, 0x4b, 0x02, 0x6e, 0xd2, 0xd2, 0xbf, 0xc0, 0xb6, 0xb1, 0x77, + 0xb2, 0x6d, 0x5b, 0x2e, 0xd6, 0x5c, 0xac, 0xfb, 0x27, 0x4c, 0x62, 0xb5, 0x87, 0x99, 0x8e, 0x78, + 0xc1, 0x85, 0x02, 0xd0, 0x3c, 0x2e, 0xb4, 0x01, 0xd3, 0x3c, 0x98, 0x40, 0x6d, 0x19, 0x87, 0x58, + 0x51, 0xdd, 0x8b, 0xcc, 0x7a, 0x53, 0x8c, 0x77, 0x85, 0xb0, 0xae, 0xb8, 0x48, 0x87, 0x0c, 0x17, + 0x66, 0xe8, 0xfc, 0xba, 0xa0, 0x27, 0xbf, 0xd8, 0x6a, 0x62, 0x9a, 0x45, 0x34, 0xd4, 0xd6, 0xe4, + 0x34, 0x93, 0xec, 0xed, 0x06, 0xfd, 0x91, 0x04, 0xb7, 0xce, 0x51, 0x74, 0x9c, 0x1d, 0x78, 0x1e, + 0xd2, 0x87, 0xe4, 0x45, 0x06, 0xd7, 0x74, 0x5a, 0xf6, 0x9e, 0xd1, 0x26, 0x4c, 0xed, 0xa9, 0x46, + 0xcb, 0xef, 0xd8, 0x83, 0xa3, 0x16, 0xa3, 0x83, 0x69, 0x73, 0x8c, 0x9d, 0xf5, 0xe4, 0xd2, 0x8f, + 0x12, 0x30, 0xb3, 0xa2, 0xeb, 0xf5, 0x3a, 0xb7, 0x8d, 0xf1, 0xf5, 0x17, 0x01, 0x4a, 0x13, 0x3e, + 0x28, 0x45, 0xef, 0x01, 0xd2, 0x0d, 0x87, 0x5d, 0x45, 0xe2, 0xec, 0xab, 0xba, 0x75, 0xe4, 0xc7, + 0x63, 0xcc, 0x88, 0x94, 0xba, 0x48, 0x40, 0x75, 0xa0, 0x88, 0x48, 0x71, 0x5c, 0xd5, 0xdb, 0x52, + 0xba, 0x35, 0xd2, 0x81, 0x30, 0x06, 0x95, 0xbc, 0x47, 0x39, 0x43, 0xe4, 0xd0, 0xbf, 0xc4, 0xb7, + 0x37, 0x48, 0xd5, 0x5d, 0x45, 0x75, 0xc4, 0x41, 0x21, 0x76, 0x09, 0x4a, 0x9e, 0xd1, 0x57, 0x9c, + 0xe0, 0xf9, 0x1f, 0x76, 0x8e, 0xc1, 0x57, 0x50, 0x9c, 0x10, 0xfa, 0x1f, 0x48, 0x90, 0x97, 0xf1, + 0x9e, 0x8d, 0x9d, 0x58, 0x97, 0x12, 0x1e, 0x43, 0xce, 0x66, 0x52, 0x95, 0x3d, 0xdb, 0x6a, 0x5f, + 0x64, 0x8c, 0x65, 0x39, 0xe3, 0x63, 0xdb, 0x6a, 0x87, 0xee, 0x85, 0x78, 0x01, 0xd3, 0x5e, 0x49, + 0xe3, 0x54, 0xc1, 0x8f, 0xe9, 0x21, 0x68, 0x26, 0x38, 0xee, 0xc0, 0x88, 0xaf, 0x42, 0x0f, 0x74, + 0x0f, 0x2b, 0x58, 0xdc, 0x38, 0x95, 0xf1, 0xdf, 0x24, 0xc8, 0xd7, 0xbb, 0xbb, 0xec, 0x26, 0xac, + 0xf8, 0xf4, 0x50, 0x81, 0x4c, 0x0b, 0xef, 0xb9, 0xca, 0x1b, 0xc5, 0xde, 0xa7, 0x09, 0x2b, 0x3d, + 0x7f, 0xf0, 0x04, 0xc0, 0xa6, 0xa7, 0xeb, 0xa8, 0x9c, 0xe4, 0x05, 0xe5, 0x64, 0x28, 0xaf, 0xef, + 0x3e, 0x95, 0x7e, 0x9c, 0x80, 0x69, 0xaf, 0xb2, 0x71, 0x5a, 0xcf, 0x97, 0x21, 0xab, 0x91, 0xbc, + 0x88, 0xd5, 0x98, 0xe1, 0x71, 0x21, 0xd1, 0x96, 0x63, 0x09, 0x66, 0xa9, 0x73, 0xa3, 0xa8, 0x9d, + 0x4e, 0xcb, 0x10, 0x20, 0x99, 0xda, 0xa5, 0x94, 0x3c, 0x43, 0x93, 0x56, 0x58, 0x0a, 0x85, 0xc7, + 0xa4, 0xff, 0xed, 0xd9, 0x18, 0xbf, 0xc6, 0x0a, 0xc5, 0x6b, 0x17, 0x89, 0x7b, 0xc9, 0x32, 0xc6, + 0x3a, 0xe1, 0xe3, 0x3d, 0xef, 0x7b, 0x30, 0x43, 0x35, 0x1b, 0xf7, 0xb1, 0x5f, 0xde, 0x1c, 0xbf, + 0x95, 0x00, 0x14, 0x94, 0xff, 0xd5, 0xb5, 0x48, 0x22, 0xbe, 0x16, 0xf9, 0x26, 0x20, 0x16, 0x0b, + 0xe9, 0x28, 0x1d, 0x6c, 0x2b, 0x0e, 0xd6, 0x2c, 0x7e, 0x3f, 0x93, 0x24, 0x17, 0x78, 0xca, 0x36, + 0xb6, 0xeb, 0x94, 0x8e, 0x1e, 0x01, 0xf8, 0x5e, 0x1b, 0x9f, 0x4e, 0x86, 0x3a, 0x6d, 0x72, 0xc6, + 0x73, 0xd7, 0x4a, 0x3f, 0x9c, 0x87, 0x1c, 0xd7, 0xe4, 0x8e, 0x69, 0x58, 0x26, 0xba, 0x0f, 0xc9, + 0x26, 0xdf, 0x66, 0xc8, 0x46, 0x2e, 0xf4, 0xf9, 0x57, 0xd2, 0x55, 0xc7, 0x64, 0x92, 0x97, 0xb0, + 0x74, 0xba, 0x6e, 0x84, 0xf3, 0xe4, 0x47, 0x7c, 0x07, 0x59, 0x3a, 0x5d, 0x17, 0xd5, 0x61, 0x5a, + 0xf3, 0x2f, 0xd8, 0x52, 0x08, 0x7b, 0x72, 0x20, 0x00, 0x8b, 0xbc, 0xd8, 0xac, 0x3a, 0x26, 0xe7, + 0xb5, 0x50, 0x02, 0x2a, 0x07, 0x6f, 0x74, 0x4a, 0xf5, 0x05, 0x8c, 0xf9, 0xe7, 0x8b, 0xc3, 0xb7, + 0x49, 0x55, 0xc7, 0x02, 0x17, 0x3f, 0xa1, 0x8f, 0x61, 0x42, 0xa7, 0x37, 0x05, 0xf1, 0x7e, 0x1d, + 0xd5, 0xf5, 0x42, 0x97, 0x33, 0x55, 0xc7, 0x64, 0xce, 0x81, 0xd6, 0x21, 0xc7, 0xfe, 0x31, 0x27, + 0x86, 0xa3, 0xd2, 0x5b, 0x83, 0x25, 0x04, 0xa6, 0x86, 0xea, 0x98, 0x9c, 0xd5, 0x7d, 0x2a, 0xfa, + 0x16, 0xa4, 0x1c, 0x4d, 0x15, 0xb8, 0xf4, 0xda, 0x80, 0x4b, 0x3e, 0x7c, 0x66, 0x9a, 0x1b, 0x3d, + 0x62, 0x57, 0x4d, 0xba, 0xc7, 0x62, 0xa1, 0x30, 0xaa, 0xf8, 0xa1, 0xa3, 0xe3, 0xa4, 0xf8, 0x98, + 0x12, 0xd0, 0x13, 0xc8, 0xaa, 0xc4, 0x1b, 0x54, 0xe8, 0xa9, 0x4c, 0xba, 0x32, 0x18, 0xbd, 0x07, + 0xdf, 0x77, 0xa2, 0xb6, 0x4a, 0xcf, 0xa7, 0x0b, 0xa2, 0x2f, 0xa8, 0x8d, 0xed, 0x26, 0x2e, 0x66, + 0x87, 0x0b, 0x0a, 0x06, 0x88, 0x79, 0x82, 0x28, 0x91, 0x78, 0x85, 0xfb, 0xe2, 0xc4, 0x0d, 0xad, + 0x54, 0x6e, 0xe0, 0x7e, 0x6f, 0xc4, 0x89, 0xa1, 0xea, 0x98, 0x9c, 0xdb, 0x0f, 0x90, 0xd1, 0x12, + 0x24, 0x9a, 0x5a, 0x71, 0x6a, 0xe0, 0x08, 0xf1, 0xce, 0xc3, 0x54, 0xc7, 0xe4, 0x44, 0x53, 0x43, + 0x9f, 0x42, 0x9a, 0x1d, 0x68, 0x38, 0x36, 0x8b, 0xf9, 0x81, 0x76, 0x22, 0x7c, 0x2c, 0xa4, 0x3a, + 0x26, 0xd3, 0x33, 0x14, 0xe4, 0x7d, 0xdb, 0x90, 0xb7, 0x59, 0x84, 0x9d, 0x88, 0x8d, 0x2d, 0x0c, + 0xdc, 0x03, 0x8f, 0x0a, 0x8f, 0xad, 0x52, 0x74, 0x10, 0xa0, 0xa3, 0xef, 0xc3, 0x5c, 0x58, 0x22, + 0xef, 0x69, 0x33, 0x03, 0xf7, 0x73, 0x07, 0x06, 0x69, 0x56, 0xc7, 0x64, 0x64, 0xf7, 0x25, 0xa2, + 0x0f, 0x61, 0x9c, 0xb5, 0x1a, 0xa2, 0x22, 0xa3, 0x82, 0x3b, 0x7a, 0x1a, 0x8c, 0xe5, 0x27, 0x9d, + 0xdf, 0xe5, 0xa1, 0x65, 0x4a, 0xcb, 0x6a, 0x16, 0x67, 0x07, 0x76, 0xfe, 0xfe, 0x50, 0x39, 0xd2, + 0xf9, 0x5d, 0x9f, 0x4a, 0xda, 0xdd, 0x66, 0x29, 0x3c, 0x12, 0x69, 0x6e, 0x60, 0xbb, 0x47, 0x44, + 0x9c, 0x55, 0xe9, 0xc1, 0x00, 0x9f, 0x4c, 0x8a, 0x66, 0xb3, 0x1b, 0x69, 0x14, 0x3a, 0xa6, 0x2e, + 0x0d, 0x2c, 0x5a, 0xff, 0xc5, 0x3d, 0x55, 0xea, 0x35, 0x79, 0x54, 0xf4, 0x02, 0x0a, 0xfc, 0xae, + 0x08, 0x7f, 0x57, 0xe2, 0x32, 0x95, 0xf7, 0x6e, 0xa4, 0xe9, 0x8a, 0x0a, 0xdd, 0xa9, 0x8e, 0xc9, + 0xd3, 0x5a, 0x38, 0x05, 0x7d, 0x06, 0x33, 0x54, 0x9e, 0xa2, 0xf9, 0x97, 0x7c, 0x14, 0x8b, 0x7d, + 0x97, 0x45, 0x0c, 0xbe, 0x0f, 0x44, 0x48, 0x2e, 0x68, 0x3d, 0x49, 0xa4, 0x1b, 0x1b, 0xa6, 0xe1, + 0x52, 0x2b, 0x3b, 0x3f, 0xb0, 0x1b, 0x87, 0x2f, 0x24, 0x24, 0xdd, 0xd8, 0x60, 0x14, 0xd2, 0x8d, + 0x5d, 0x1e, 0xa6, 0xc6, 0x9b, 0xe3, 0xed, 0x81, 0xdd, 0x38, 0x2a, 0x9e, 0x8d, 0x74, 0x63, 0x37, + 0x48, 0x27, 0xdd, 0x98, 0x19, 0x88, 0x1e, 0xb9, 0xef, 0x0c, 0xec, 0xc6, 0x03, 0xcf, 0x45, 0x93, + 0x6e, 0xac, 0xf6, 0x25, 0xa2, 0x35, 0x00, 0xe6, 0xd4, 0xd0, 0x49, 0xf1, 0xda, 0xc0, 0xc9, 0xa0, + 0x37, 0x50, 0x8d, 0x4c, 0x06, 0x2d, 0x41, 0x23, 0x86, 0x8c, 0x42, 0x29, 0x85, 0x6e, 0xd1, 0x16, + 0x17, 0x06, 0x1a, 0xb2, 0xbe, 0xcd, 0x53, 0x62, 0xc8, 0x8e, 0x3c, 0x22, 0x99, 0x55, 0xd8, 0x7a, + 0x71, 0x71, 0x71, 0xb0, 0x59, 0x0e, 0x6e, 0x1e, 0x51, 0xb3, 0x4c, 0x09, 0x68, 0x05, 0x32, 0x64, + 0xce, 0x3f, 0xa1, 0x66, 0xe8, 0xfa, 0x40, 0xff, 0xb4, 0xe7, 0xe4, 0x4b, 0x75, 0x4c, 0x4e, 0xbf, + 0xe2, 0x24, 0xf2, 0x7a, 0xb6, 0x6e, 0x56, 0x2c, 0x0d, 0x7c, 0x7d, 0x68, 0xd5, 0x95, 0xbc, 0x9e, + 0x71, 0x20, 0x0d, 0x2e, 0xb1, 0xb6, 0xe2, 0xc7, 0x92, 0x6d, 0x7e, 0x86, 0xb6, 0x78, 0x83, 0x8a, + 0x1a, 0xb8, 0xf4, 0x14, 0x79, 0x5a, 0xba, 0x3a, 0x26, 0xcf, 0xaa, 0xfd, 0xa9, 0x64, 0xc0, 0xf3, + 0xa9, 0x87, 0x2d, 0x58, 0x15, 0x6f, 0x0e, 0x1c, 0xf0, 0x11, 0xab, 0x7d, 0x64, 0xc0, 0xab, 0x01, + 0x32, 0x9b, 0x80, 0x74, 0xc5, 0x71, 0xd8, 0x86, 0xfe, 0xad, 0x21, 0x13, 0x50, 0xcf, 0x1a, 0x01, + 0x9b, 0x80, 0xf4, 0x3a, 0xe3, 0x24, 0x82, 0xb4, 0x16, 0x56, 0x6d, 0x6e, 0x66, 0x6f, 0x0f, 0x14, + 0xd4, 0x77, 0xc7, 0x1f, 0x11, 0xa4, 0x79, 0x44, 0xe2, 0xf0, 0xd8, 0xe2, 0x92, 0x19, 0xee, 0x30, + 0xde, 0x19, 0xe8, 0xf0, 0x44, 0xde, 0x85, 0x43, 0x1c, 0x1e, 0x3b, 0x94, 0x80, 0x7e, 0x19, 0x26, + 0x39, 0xa0, 0x2b, 0xde, 0x1d, 0xe2, 0xc6, 0x06, 0x91, 0x38, 0x19, 0xd7, 0x9c, 0x87, 0x59, 0x59, + 0x06, 0x24, 0x59, 0xf5, 0xde, 0x1d, 0x62, 0x65, 0xfb, 0xb0, 0x2c, 0xb3, 0xb2, 0x3e, 0x99, 0x58, + 0x59, 0xd6, 0x4f, 0xf9, 0x5c, 0x77, 0x6f, 0xa0, 0x95, 0xed, 0x3f, 0x51, 0x43, 0xac, 0xec, 0x2b, + 0x9f, 0x4a, 0x6a, 0xe6, 0x30, 0x10, 0x55, 0xfc, 0xc6, 0xc0, 0x9a, 0x85, 0x31, 0x25, 0xa9, 0x19, + 0xe7, 0x21, 0xcd, 0xc6, 0x5c, 0x62, 0xa6, 0xe9, 0x6f, 0x0e, 0xbe, 0x01, 0xa0, 0x17, 0x7a, 0x54, + 0xc5, 0x62, 0x26, 0xd3, 0xb0, 0x67, 0xa8, 0x6c, 0x7e, 0xde, 0x99, 0x6b, 0xea, 0xbd, 0xe1, 0x86, + 0x2a, 0xea, 0x28, 0xb7, 0x67, 0xa8, 0x42, 0x89, 0xb4, 0xa8, 0xec, 0x10, 0x1b, 0x1d, 0xdf, 0x4b, + 0x43, 0x2e, 0x2b, 0xe8, 0x39, 0x50, 0x48, 0x8b, 0xea, 0x11, 0xfd, 0x21, 0xd4, 0x65, 0xb7, 0x6a, + 0x14, 0x97, 0x87, 0x0f, 0xa1, 0xf0, 0xed, 0x1e, 0xde, 0x10, 0xe2, 0x64, 0x6f, 0xce, 0x14, 0x1e, + 0xc6, 0xfb, 0xc3, 0xe7, 0xcc, 0x5e, 0xd7, 0x82, 0xcd, 0x99, 0xdc, 0xa7, 0xf8, 0x0b, 0x12, 0x2c, + 0xb2, 0xb2, 0xd1, 0xf5, 0xbe, 0x13, 0xc5, 0x5b, 0x3b, 0x0d, 0x1c, 0x9f, 0xb8, 0x4f, 0x5f, 0xf0, + 0xe1, 0xa0, 0xe2, 0x9e, 0xb3, 0x16, 0x5c, 0x1d, 0x93, 0xdf, 0x51, 0x87, 0xe5, 0x5b, 0x9d, 0xe4, + 0x5b, 0xaa, 0xde, 0x39, 0xd2, 0xe9, 0x42, 0x61, 0x3d, 0x95, 0xbe, 0x52, 0x28, 0xae, 0xa7, 0xd2, + 0x57, 0x0b, 0xf3, 0xeb, 0xa9, 0xf4, 0x5b, 0x85, 0xb7, 0x4b, 0xff, 0xfd, 0x2a, 0x4c, 0x09, 0xe4, + 0xc7, 0x10, 0xd1, 0x83, 0x20, 0x22, 0xba, 0x36, 0x08, 0x11, 0x71, 0xac, 0xc8, 0x21, 0xd1, 0x83, + 0x20, 0x24, 0xba, 0x36, 0x08, 0x12, 0xf9, 0x3c, 0x04, 0x13, 0x35, 0x06, 0x61, 0xa2, 0x77, 0x47, + 0xc0, 0x44, 0x9e, 0xa8, 0x5e, 0x50, 0xb4, 0xd6, 0x0f, 0x8a, 0x6e, 0x0e, 0x07, 0x45, 0x9e, 0xa8, + 0x00, 0x2a, 0x7a, 0xd4, 0x83, 0x8a, 0xae, 0x0f, 0x41, 0x45, 0x1e, 0xbf, 0x80, 0x45, 0x1b, 0x91, + 0xb0, 0xe8, 0xf6, 0x79, 0xb0, 0xc8, 0x93, 0x13, 0xc2, 0x45, 0x1f, 0x84, 0x70, 0xd1, 0xc2, 0x40, + 0x5c, 0xe4, 0x71, 0x33, 0x60, 0xf4, 0x49, 0x2f, 0x30, 0xba, 0x3e, 0x04, 0x18, 0xf9, 0x35, 0xe0, + 0xc8, 0xa8, 0x1a, 0x85, 0x8c, 0x6e, 0x9d, 0x83, 0x8c, 0x3c, 0x29, 0x41, 0x68, 0x54, 0x8d, 0x82, + 0x46, 0xb7, 0xce, 0x81, 0x46, 0x3d, 0x92, 0x18, 0x36, 0xda, 0x8a, 0xc6, 0x46, 0x77, 0xce, 0xc5, + 0x46, 0x9e, 0xb4, 0x30, 0x38, 0x5a, 0x0e, 0x80, 0xa3, 0x77, 0x06, 0x80, 0x23, 0x8f, 0x95, 0xa0, + 0xa3, 0x6f, 0xf7, 0xa1, 0xa3, 0xd2, 0x30, 0x74, 0xe4, 0xf1, 0x7a, 0xf0, 0xe8, 0xf9, 0x00, 0x78, + 0x74, 0xf7, 0x7c, 0x78, 0xe4, 0x09, 0xeb, 0xc1, 0x47, 0xea, 0x50, 0x7c, 0xf4, 0xde, 0x88, 0xf8, + 0xc8, 0x93, 0x1e, 0x05, 0x90, 0x3e, 0x0a, 0x03, 0xa4, 0xc5, 0xc1, 0x00, 0xc9, 0x13, 0xc3, 0x11, + 0xd2, 0x46, 0x24, 0x42, 0xba, 0x7d, 0x1e, 0x42, 0xf2, 0xc7, 0x41, 0x10, 0x22, 0x6d, 0x45, 0x43, + 0xa4, 0x3b, 0xe7, 0x42, 0x24, 0xbf, 0xf9, 0x43, 0x18, 0x69, 0x23, 0x12, 0x23, 0xdd, 0x3e, 0x0f, + 0x23, 0xf9, 0x85, 0x0b, 0x82, 0xa4, 0x97, 0x03, 0x41, 0xd2, 0xbd, 0x51, 0x40, 0x92, 0x27, 0xb4, + 0x0f, 0x25, 0x7d, 0x3e, 0x18, 0x25, 0x7d, 0xe3, 0x02, 0xb7, 0x26, 0x46, 0xc2, 0xa4, 0x6f, 0xf7, + 0xc1, 0xa4, 0xd2, 0x30, 0x98, 0xe4, 0xf7, 0x67, 0x81, 0x93, 0xd4, 0xa1, 0xa8, 0xe6, 0xbd, 0x11, + 0x51, 0x8d, 0xdf, 0xf9, 0x22, 0x60, 0x4d, 0x25, 0x02, 0xd6, 0xdc, 0x1c, 0x0e, 0x6b, 0x7c, 0x73, + 0xee, 0xe3, 0x9a, 0x6a, 0x14, 0xae, 0xb9, 0x75, 0x0e, 0xae, 0xf1, 0xad, 0x50, 0x00, 0xd8, 0x3c, + 0xea, 0x01, 0x36, 0xd7, 0xcf, 0x8d, 0x18, 0x0a, 0x20, 0x9b, 0xd5, 0x7e, 0x64, 0x73, 0x63, 0x28, + 0xb2, 0xf1, 0x24, 0xf8, 0xd0, 0xe6, 0x51, 0x0f, 0xb4, 0xb9, 0x3e, 0x04, 0xda, 0xf8, 0x05, 0xe0, + 0xd8, 0x46, 0x1f, 0x8e, 0x6d, 0x96, 0x46, 0xc5, 0x36, 0x9e, 0xe0, 0x48, 0x70, 0xb3, 0x15, 0x0d, + 0x6e, 0xee, 0x8c, 0xb8, 0x69, 0xdf, 0x87, 0x6e, 0xaa, 0x51, 0xe8, 0xe6, 0xd6, 0x39, 0xe8, 0x26, + 0x38, 0x87, 0x78, 0xf0, 0xa6, 0x1a, 0x05, 0x6f, 0x6e, 0x9d, 0x03, 0x6f, 0x7c, 0x49, 0x01, 0x7c, + 0xd3, 0x18, 0x84, 0x6f, 0xde, 0x1d, 0x01, 0xdf, 0xf8, 0xce, 0x4b, 0x0f, 0xc0, 0xf9, 0xb4, 0x17, + 0xe0, 0x94, 0x86, 0x01, 0x1c, 0x7f, 0x44, 0x0a, 0x84, 0xb3, 0x15, 0x8d, 0x70, 0xee, 0x9c, 0x8b, + 0x70, 0x82, 0x46, 0x32, 0x00, 0x71, 0x36, 0x22, 0x21, 0xce, 0xed, 0xf3, 0x20, 0x8e, 0x6f, 0x24, + 0x83, 0x18, 0xe7, 0xd3, 0x5e, 0x8c, 0x53, 0x1a, 0x86, 0x71, 0xfc, 0xca, 0x09, 0x90, 0x53, 0x8d, + 0x02, 0x39, 0xb7, 0xce, 0x01, 0x39, 0x7e, 0xe3, 0x05, 0x50, 0x8e, 0x3a, 0x14, 0xe5, 0xbc, 0x37, + 0x22, 0xca, 0xe9, 0x31, 0x5c, 0x61, 0x98, 0x53, 0x8d, 0x82, 0x39, 0xb7, 0xce, 0x81, 0x39, 0x81, + 0xc2, 0xfa, 0x38, 0x67, 0x2b, 0x1a, 0xe7, 0xdc, 0x39, 0x17, 0xe7, 0xf4, 0x8c, 0x26, 0x01, 0x74, + 0x36, 0x22, 0x81, 0xce, 0xed, 0xf3, 0x80, 0x4e, 0xcf, 0xc4, 0xc7, 0x9d, 0x83, 0xbf, 0x38, 0x3a, + 0xd2, 0xf9, 0xe8, 0xe2, 0x48, 0xc7, 0x7b, 0x67, 0x2c, 0x50, 0x67, 0x3d, 0x95, 0x7e, 0xbb, 0xf0, + 0x4e, 0xe9, 0xaf, 0x4c, 0xc2, 0x44, 0xd5, 0x8b, 0x85, 0xf1, 0x4b, 0x29, 0xbd, 0xc9, 0x65, 0x4c, + 0x68, 0x8d, 0x8c, 0x58, 0x6a, 0xf7, 0xce, 0xbf, 0x77, 0xaf, 0xff, 0x4e, 0x38, 0xce, 0xfa, 0x06, + 0xe7, 0x9b, 0xd1, 0x07, 0x30, 0xd5, 0x75, 0xb0, 0xad, 0x74, 0x6c, 0xc3, 0xb2, 0x0d, 0x97, 0x9d, + 0x15, 0x91, 0x56, 0x0b, 0x5f, 0x9e, 0x2e, 0xe4, 0x76, 0x1c, 0x6c, 0x6f, 0x73, 0xba, 0x9c, 0xeb, + 0x06, 0x9e, 0xc4, 0x67, 0xaf, 0xc6, 0x47, 0xff, 0xec, 0xd5, 0x73, 0x28, 0xd8, 0x58, 0xd5, 0x43, + 0x1e, 0x08, 0xbb, 0xec, 0x28, 0xba, 0xcf, 0xd0, 0x63, 0x58, 0x22, 0x27, 0xbd, 0xf4, 0x68, 0xda, + 0x0e, 0x13, 0xd1, 0x7d, 0xb8, 0xd4, 0x56, 0x8f, 0x69, 0x3c, 0xa5, 0x22, 0x9c, 0x3a, 0x1a, 0x23, + 0xc9, 0xbe, 0x28, 0x85, 0xda, 0xea, 0x31, 0xfd, 0x86, 0x16, 0x4b, 0xa2, 0x1f, 0xbd, 0xb8, 0x05, + 0x79, 0xdd, 0x70, 0x5c, 0xc3, 0xd4, 0x5c, 0x7e, 0xf7, 0x2d, 0xbb, 0x37, 0x76, 0x4a, 0x50, 0xd9, + 0x05, 0xb7, 0xf7, 0x60, 0x86, 0x87, 0xdb, 0x07, 0xb6, 0x08, 0x81, 0xc7, 0xb0, 0xd1, 0x04, 0x6f, + 0x57, 0x10, 0x95, 0x61, 0xba, 0xa9, 0xba, 0xf8, 0x48, 0x3d, 0x51, 0xc4, 0x59, 0xad, 0x2c, 0xbd, + 0x25, 0xf2, 0xad, 0xb3, 0xd3, 0x85, 0xa9, 0x27, 0x2c, 0xa9, 0xef, 0xc8, 0xd6, 0x54, 0x33, 0x90, + 0xa0, 0xa3, 0x3b, 0x30, 0xad, 0x3a, 0x27, 0xa6, 0x46, 0xd5, 0x83, 0x4d, 0xa7, 0xeb, 0x50, 0x48, + 0x91, 0x96, 0xf3, 0x94, 0x5c, 0x16, 0x54, 0x74, 0x1d, 0x72, 0x3c, 0x16, 0x9d, 0x7d, 0x88, 0x67, + 0x9a, 0x56, 0x95, 0x7f, 0xd5, 0x81, 0x7e, 0x8b, 0x07, 0x3d, 0x82, 0x79, 0x7e, 0xdb, 0xfd, 0x91, + 0x6a, 0xeb, 0x0a, 0xd5, 0xba, 0xdf, 0x3f, 0x0b, 0x54, 0xec, 0x15, 0x76, 0xbb, 0x3d, 0xc9, 0x40, + 0x54, 0xed, 0x5f, 0xaa, 0xb0, 0x05, 0x33, 0x5a, 0xcb, 0xf0, 0x10, 0x00, 0xab, 0xf9, 0xcc, 0x40, + 0x3b, 0x5b, 0xa6, 0x79, 0xfd, 0x2d, 0xd2, 0x69, 0x2d, 0x4c, 0x40, 0x75, 0xa0, 0x97, 0xc8, 0x28, + 0x1d, 0xab, 0x65, 0x68, 0x27, 0xd4, 0xf9, 0x0f, 0xdf, 0xd4, 0x3d, 0xf4, 0xee, 0xfc, 0x97, 0xaa, + 0xe1, 0x6e, 0x53, 0x4e, 0x19, 0x8e, 0xbc, 0xff, 0xec, 0x12, 0xde, 0xf5, 0x54, 0x3a, 0x57, 0x98, + 0x5a, 0x4f, 0xa5, 0xf3, 0x85, 0xe9, 0xd2, 0xdf, 0x90, 0x60, 0xba, 0xa7, 0x2c, 0xa8, 0x0a, 0x97, + 0x74, 0x6f, 0xa8, 0x28, 0xfc, 0x28, 0x93, 0x61, 0x99, 0xfc, 0xf2, 0xf1, 0xd9, 0x2f, 0x4f, 0x17, + 0xa6, 0x69, 0xee, 0x27, 0x5e, 0x92, 0x3c, 0xe7, 0x73, 0xf8, 0x54, 0xf4, 0x11, 0xe4, 0x99, 0xfb, + 0xe8, 0x7d, 0x6d, 0x8e, 0xc6, 0x97, 0xaf, 0xce, 0x7c, 0x79, 0xba, 0x30, 0x45, 0x7d, 0x46, 0x71, + 0x83, 0xb0, 0x3c, 0xd5, 0x0a, 0x3e, 0x96, 0xfe, 0xba, 0x04, 0xb9, 0xd0, 0xe1, 0xa0, 0x47, 0x3d, + 0x3b, 0xe8, 0x57, 0xa3, 0x71, 0xe7, 0xa0, 0xa0, 0xbb, 0x34, 0xef, 0xe7, 0x22, 0x82, 0x71, 0x61, + 0x30, 0x6e, 0xa1, 0xab, 0x30, 0x22, 0x6c, 0x43, 0xb0, 0x7d, 0x9c, 0xfa, 0x5b, 0x5f, 0x2c, 0x8c, + 0x95, 0x7e, 0x9c, 0x82, 0xa9, 0xf0, 0x21, 0xa0, 0x5a, 0x4f, 0xb9, 0xa2, 0xe6, 0x85, 0x10, 0xc7, + 0xd2, 0x90, 0x7b, 0x13, 0x33, 0xfe, 0x5d, 0xff, 0xac, 0x98, 0x8b, 0x43, 0xe2, 0x04, 0x82, 0xe5, + 0xf4, 0x19, 0xe7, 0xff, 0x52, 0xd2, 0xb3, 0xaf, 0x4b, 0x30, 0x4e, 0x6f, 0xe7, 0xe1, 0x45, 0x8b, + 0x3a, 0x5f, 0x5e, 0x21, 0xe9, 0x32, 0xcb, 0x46, 0xec, 0x71, 0xe3, 0x8d, 0x2e, 0xc7, 0xf3, 0x87, + 0xc1, 0xc5, 0x3f, 0xeb, 0xc7, 0xaf, 0x48, 0x1c, 0xbf, 0xd8, 0x15, 0x89, 0x6c, 0x47, 0xbf, 0xd5, + 0x62, 0x73, 0x1d, 0xb3, 0x48, 0x13, 0x7d, 0x87, 0xb8, 0xa9, 0x08, 0xfe, 0xb5, 0xc5, 0x25, 0x99, + 0x7f, 0x6d, 0x31, 0x10, 0x05, 0x9a, 0xf7, 0x44, 0x30, 0xf3, 0xd5, 0x13, 0x90, 0x3a, 0xf9, 0x26, + 0x01, 0xa9, 0x2c, 0x94, 0x99, 0xf7, 0x97, 0x7f, 0x2b, 0xf1, 0x70, 0x90, 0xa7, 0x96, 0x75, 0xd0, + 0xf5, 0x02, 0x49, 0xe7, 0x83, 0x17, 0x14, 0xa6, 0xbf, 0x3c, 0x5d, 0x48, 0xc9, 0xde, 0x0d, 0x85, + 0x51, 0xf6, 0x3e, 0xf1, 0x8b, 0xd9, 0xfb, 0xeb, 0x90, 0xeb, 0xd8, 0x78, 0x0f, 0xbb, 0xda, 0xbe, + 0x62, 0x76, 0xdb, 0xfc, 0x1c, 0x4a, 0x56, 0xd0, 0xb6, 0xba, 0x6d, 0xf4, 0x2e, 0x14, 0xbc, 0x2c, + 0x1c, 0x59, 0x8b, 0x3b, 0xaa, 0x04, 0x9d, 0xe3, 0xf0, 0xd2, 0xff, 0x94, 0x60, 0x36, 0x54, 0x27, + 0x3e, 0x12, 0xd6, 0x21, 0xeb, 0x1b, 0x01, 0xa7, 0x28, 0x5d, 0x30, 0xa0, 0x32, 0xc8, 0x8c, 0x14, + 0xb8, 0x2c, 0x5e, 0x4b, 0x6f, 0xb2, 0xf7, 0xc5, 0x26, 0x2e, 0x28, 0xf6, 0x92, 0x2f, 0x67, 0x2d, + 0xf0, 0x02, 0x6f, 0x68, 0x24, 0x47, 0x1a, 0x1a, 0xa5, 0x1f, 0x49, 0x50, 0xa0, 0x2f, 0x78, 0x8c, + 0xb1, 0x1e, 0x8b, 0x4d, 0x12, 0xe1, 0xca, 0x89, 0xd1, 0x4f, 0x9a, 0x84, 0xbe, 0xc4, 0x91, 0x0c, + 0x7f, 0x89, 0xa3, 0xf4, 0x85, 0x04, 0x79, 0xaf, 0x84, 0xec, 0x2b, 0x76, 0x43, 0xee, 0xc1, 0x7c, + 0xb3, 0x6f, 0xb7, 0x89, 0xeb, 0x3a, 0x46, 0xfa, 0xb0, 0x5e, 0xf0, 0xba, 0x0e, 0xf6, 0x9d, 0xb1, + 0xbf, 0x23, 0x7a, 0x0e, 0x29, 0x62, 0xd9, 0xbf, 0x8a, 0xe1, 0x0d, 0x0e, 0xdd, 0xc8, 0xf4, 0x63, + 0xa0, 0x56, 0xeb, 0x90, 0xdd, 0x93, 0x32, 0x92, 0xb1, 0x42, 0x3c, 0x08, 0x0a, 0xf8, 0x1a, 0x9c, + 0xde, 0xa8, 0xd3, 0xcf, 0x84, 0xb2, 0xff, 0x4e, 0xe9, 0x71, 0x40, 0x81, 0xb4, 0xf1, 0x89, 0x96, + 0x46, 0x32, 0xa0, 0x42, 0x4b, 0xac, 0xaf, 0xfc, 0x61, 0xb0, 0x25, 0x2a, 0x87, 0x04, 0x7b, 0x3d, + 0x84, 0xe4, 0xa1, 0xda, 0x1a, 0x16, 0xfc, 0x15, 0x6a, 0x39, 0x99, 0xe4, 0x46, 0x8f, 0x43, 0x37, + 0x58, 0x24, 0x06, 0xe3, 0x84, 0x7e, 0x95, 0x86, 0x6e, 0xba, 0xf8, 0x30, 0xdc, 0xd7, 0x87, 0xbe, + 0x3e, 0xd8, 0xe9, 0x3f, 0x4e, 0xfd, 0xe4, 0x8b, 0x05, 0xa9, 0xf4, 0x21, 0x5c, 0x7d, 0x62, 0x39, + 0x8e, 0xd1, 0x21, 0xd8, 0x90, 0x0e, 0x20, 0x62, 0xbb, 0x3d, 0x4b, 0x96, 0xee, 0xd0, 0x55, 0x02, + 0x93, 0x8d, 0xf8, 0x8c, 0xec, 0x3d, 0x97, 0xfe, 0x99, 0x04, 0x57, 0xfa, 0x39, 0x99, 0x42, 0xa2, + 0x0e, 0xf5, 0x4d, 0x6a, 0x96, 0x7f, 0xa3, 0xdb, 0xf9, 0x1d, 0x4b, 0x64, 0x27, 0x3e, 0x20, 0x7f, + 0xa7, 0xd2, 0x56, 0xe9, 0x48, 0xe7, 0x07, 0x8f, 0xf3, 0x9c, 0xbc, 0xc9, 0xa8, 0xfe, 0xa0, 0x4f, + 0x8d, 0x36, 0xe8, 0x1b, 0x30, 0xbd, 0x6e, 0x19, 0x26, 0x71, 0x35, 0x45, 0x7d, 0x57, 0x20, 0xbf, + 0x6b, 0x98, 0xaa, 0x7d, 0xa2, 0x88, 0x53, 0xdd, 0xac, 0x4d, 0xe7, 0xa3, 0x0a, 0xcb, 0x72, 0xc8, + 0x53, 0x8c, 0x83, 0x3f, 0x96, 0x7e, 0x2a, 0x41, 0xc1, 0x17, 0xcb, 0x8d, 0xe7, 0x37, 0x01, 0xb4, + 0x56, 0xd7, 0x71, 0xb1, 0x2d, 0x0e, 0xd3, 0xe4, 0x58, 0xf0, 0x75, 0x99, 0x51, 0x6b, 0x6b, 0x72, + 0x86, 0x67, 0xa8, 0xe9, 0xe8, 0x46, 0xf8, 0x7a, 0x83, 0xf1, 0x55, 0x38, 0xeb, 0xbb, 0xd4, 0x00, + 0xdd, 0x86, 0xb4, 0xe3, 0x5a, 0xb6, 0x07, 0x6a, 0xc6, 0x57, 0xb3, 0x67, 0x81, 0xeb, 0xd7, 0xe9, + 0xb1, 0x5d, 0x92, 0x6f, 0x05, 0xf2, 0x64, 0x3e, 0x3e, 0xc4, 0x5e, 0x95, 0x52, 0xe7, 0x57, 0x89, + 0x71, 0xf0, 0xc7, 0x7b, 0x75, 0x98, 0x8d, 0x98, 0x88, 0x50, 0x1e, 0x20, 0xf0, 0x09, 0x17, 0xfe, + 0xf1, 0xd9, 0x95, 0x35, 0x65, 0x67, 0xab, 0xfc, 0x6c, 0x73, 0xb3, 0xd6, 0x68, 0x54, 0xd6, 0x0a, + 0x12, 0x2a, 0x40, 0x2e, 0xf4, 0x01, 0x98, 0x04, 0xfb, 0x1c, 0xed, 0xbd, 0x3f, 0x03, 0xe0, 0x7f, + 0x57, 0x8a, 0xc8, 0xda, 0xa8, 0x7c, 0xa6, 0xbc, 0x58, 0x79, 0xba, 0x53, 0xa9, 0x17, 0xc6, 0x10, + 0x82, 0xfc, 0xea, 0x4a, 0xa3, 0x5c, 0x55, 0xe4, 0x4a, 0x7d, 0xfb, 0xd9, 0x56, 0xbd, 0x22, 0x3e, + 0x63, 0x7b, 0x6f, 0x0d, 0x72, 0xc1, 0xeb, 0x60, 0xd0, 0x2c, 0x4c, 0x97, 0xab, 0x95, 0xf2, 0x86, + 0xf2, 0xa2, 0xb6, 0xa2, 0x3c, 0xdf, 0xa9, 0xec, 0x54, 0x0a, 0x63, 0xb4, 0x68, 0x94, 0xf8, 0x78, + 0xe7, 0xe9, 0xd3, 0x82, 0x84, 0xa6, 0x21, 0xcb, 0x9e, 0xe9, 0xc7, 0x62, 0x0a, 0x89, 0x7b, 0x9b, + 0x90, 0x0d, 0x5c, 0x1c, 0x4b, 0x5e, 0xb7, 0xbd, 0x53, 0xaf, 0x2a, 0x8d, 0xda, 0x66, 0xa5, 0xde, + 0x58, 0xd9, 0xdc, 0x66, 0x32, 0x28, 0x6d, 0x65, 0xf5, 0x99, 0xdc, 0x28, 0x48, 0xde, 0x73, 0xe3, + 0xd9, 0x4e, 0xb9, 0x2a, 0xaa, 0x51, 0x4a, 0xa5, 0x93, 0x85, 0xe4, 0xbd, 0x5f, 0x93, 0xe0, 0xca, + 0x80, 0x4b, 0x51, 0x50, 0x16, 0x26, 0x77, 0x4c, 0x7a, 0x73, 0x66, 0x61, 0x0c, 0x4d, 0x05, 0xee, + 0x45, 0x29, 0x48, 0x28, 0xcd, 0xee, 0xa4, 0x28, 0x24, 0xd0, 0x04, 0x24, 0xea, 0x0f, 0x0b, 0x49, + 0x52, 0xd2, 0xc0, 0xb5, 0x22, 0x85, 0x14, 0xca, 0xf0, 0x5b, 0x11, 0x0a, 0xe3, 0x28, 0xe7, 0x5f, + 0x4b, 0x50, 0x98, 0x20, 0xa2, 0xbc, 0x83, 0xfd, 0x85, 0xc9, 0x7b, 0xd7, 0x21, 0x70, 0x48, 0x1a, + 0x01, 0x4c, 0x3c, 0x55, 0x5d, 0xec, 0xb8, 0x85, 0x31, 0x34, 0x09, 0xc9, 0x95, 0x56, 0xab, 0x20, + 0x3d, 0xf8, 0x59, 0x12, 0xd2, 0xe2, 0x73, 0x28, 0xe8, 0x29, 0x8c, 0xb3, 0x35, 0xd7, 0x85, 0xc1, + 0x2e, 0x2d, 0x1d, 0x14, 0xf3, 0x8b, 0xe7, 0xf9, 0xbc, 0xa5, 0x31, 0xf4, 0x67, 0x21, 0x1b, 0x70, + 0x1a, 0xd0, 0xc0, 0x75, 0xa3, 0x90, 0xa3, 0x34, 0x7f, 0xfb, 0xbc, 0x6c, 0x9e, 0xfc, 0x97, 0x90, + 0xf1, 0x8c, 0x18, 0xba, 0x31, 0xcc, 0xc4, 0x09, 0xd9, 0xc3, 0xed, 0x20, 0xb1, 0x52, 0xa5, 0xb1, + 0xf7, 0x25, 0x64, 0x03, 0xea, 0x37, 0x62, 0x28, 0x6a, 0x2b, 0x7e, 0xa0, 0x95, 0x9c, 0xbf, 0x37, + 0x52, 0x6e, 0xff, 0x9d, 0xcf, 0x21, 0x45, 0x2c, 0x04, 0x8a, 0x72, 0x73, 0x7a, 0x2c, 0xd2, 0xfc, + 0x8d, 0xa1, 0x79, 0x84, 0x7e, 0x56, 0xdf, 0xfd, 0xc9, 0x1f, 0x5f, 0x1b, 0xfb, 0xc9, 0xd9, 0x35, + 0xe9, 0xa7, 0x67, 0xd7, 0xa4, 0x9f, 0x9d, 0x5d, 0x93, 0xfe, 0xf3, 0xd9, 0x35, 0xe9, 0xaf, 0xfd, + 0xfc, 0xda, 0xd8, 0x4f, 0x7f, 0x7e, 0x6d, 0xec, 0x67, 0x3f, 0xbf, 0x36, 0xf6, 0xf9, 0x24, 0xe7, + 0xde, 0x9d, 0xa0, 0xdf, 0x1c, 0x7f, 0xf8, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x9e, 0xf5, 0x3d, + 0x98, 0x96, 0x7d, 0x00, 0x00, } diff --git a/pkg/roachpb/api.proto b/pkg/roachpb/api.proto index 6d19f14cbfab..873bbe961023 100644 --- a/pkg/roachpb/api.proto +++ b/pkg/roachpb/api.proto @@ -2203,10 +2203,31 @@ message GossipSubscriptionEvent { Error error = 4; } -// Batch and RangeFeed service implemeted by nodes for KV API requests. +// JoinNodeRequest is used to specify to the server node what the client's +// binary version is. If it's not compatible with the rest of the cluster, the +// join attempt is refused. +message JoinNodeRequest { + roachpb.Version binary_version = 1; +} + +// JoinNodeResponse informs the joining node what the cluster id is, what +// node id was allocated to it, and what store ID to use for its first store. It +// also informs the node what the current active version is. +message JoinNodeResponse { + bytes cluster_id = 1 [(gogoproto.customname) = "ClusterID"]; + int32 node_id = 2 [(gogoproto.customname) = "NodeID"]; + int32 store_id = 3 [(gogoproto.customname) = "StoreID"]; + roachpb.Version active_version = 4; +} + +// Batch and RangeFeed service implemented by nodes for KV API requests. service Internal { rpc Batch (BatchRequest) returns (BatchResponse) {} rpc RangeLookup (RangeLookupRequest) returns (RangeLookupResponse) {} rpc RangeFeed (RangeFeedRequest) returns (stream RangeFeedEvent) {} rpc GossipSubscription (GossipSubscriptionRequest) returns (stream GossipSubscriptionEvent) {} + + // Join a bootstrapped cluster. If the target node is itself not part of a + // bootstrapped cluster, an appropriate error is returned. + rpc Join(JoinNodeRequest) returns (JoinNodeResponse) { } } diff --git a/pkg/rpc/context.go b/pkg/rpc/context.go index 03978f2daef6..d9e3d0664b4d 100644 --- a/pkg/rpc/context.go +++ b/pkg/rpc/context.go @@ -505,6 +505,13 @@ func (a internalClientAdapter) RangeLookup( return a.InternalServer.RangeLookup(ctx, rl) } +// Join implements the roachpb.InternalClient interface. +func (a internalClientAdapter) Join( + ctx context.Context, req *roachpb.JoinNodeRequest, _ ...grpc.CallOption, +) (*roachpb.JoinNodeResponse, error) { + return a.InternalServer.Join(ctx, req) +} + type respStreamClientAdapter struct { ctx context.Context respC chan interface{} diff --git a/pkg/rpc/context_test.go b/pkg/rpc/context_test.go index f90d68cb81da..9c93120de8d5 100644 --- a/pkg/rpc/context_test.go +++ b/pkg/rpc/context_test.go @@ -162,6 +162,8 @@ func TestHeartbeatCB(t *testing.T) { }) } +var _ roachpb.InternalServer = &internalServer{} + type internalServer struct{} func (*internalServer) Batch( @@ -188,6 +190,12 @@ func (*internalServer) GossipSubscription( panic("unimplemented") } +func (*internalServer) Join( + context.Context, *roachpb.JoinNodeRequest, +) (*roachpb.JoinNodeResponse, error) { + panic("unimplemented") +} + // TestInternalServerAddress verifies that RPCContext uses AdvertiseAddr, not Addr, to // determine whether to apply the local server optimization. // diff --git a/pkg/server/config.go b/pkg/server/config.go index 8e151721b609..6a6b6cb0f4fa 100644 --- a/pkg/server/config.go +++ b/pkg/server/config.go @@ -172,8 +172,9 @@ type KVConfig struct { // in zone configs. Attrs string - // JoinList is a list of node addresses that act as bootstrap hosts for - // connecting to the gossip network. + // JoinList is a list of node addresses that is used to form a network of KV + // servers. Assuming a connected graph, it suffices to initialize any server + // in the network. JoinList base.JoinListType // JoinPreferSRVRecords, if set, causes the lookup logic for the @@ -652,11 +653,13 @@ func (cfg *Config) InitNode(ctx context.Context) error { // FilterGossipBootstrapResolvers removes any gossip bootstrap resolvers which // match either this node's listen address or its advertised host address. -func (cfg *Config) FilterGossipBootstrapResolvers( - ctx context.Context, listen, advert net.Addr, -) []resolver.Resolver { +func (cfg *Config) FilterGossipBootstrapResolvers(ctx context.Context) []resolver.Resolver { + var listen, advert net.Addr + listen = util.NewUnresolvedAddr("tcp", cfg.Addr) + advert = util.NewUnresolvedAddr("tcp", cfg.AdvertiseAddr) filtered := make([]resolver.Resolver, 0, len(cfg.GossipBootstrapResolvers)) addrs := make([]string, 0, len(cfg.GossipBootstrapResolvers)) + for _, r := range cfg.GossipBootstrapResolvers { if r.Addr() == advert.String() || r.Addr() == listen.String() { if log.V(1) { diff --git a/pkg/server/config_test.go b/pkg/server/config_test.go index 71824616979d..d88f14ab868c 100644 --- a/pkg/server/config_test.go +++ b/pkg/server/config_test.go @@ -21,7 +21,6 @@ import ( "github.com/cockroachdb/cockroach/pkg/base" "github.com/cockroachdb/cockroach/pkg/gossip/resolver" "github.com/cockroachdb/cockroach/pkg/settings/cluster" - "github.com/cockroachdb/cockroach/pkg/util" "github.com/cockroachdb/cockroach/pkg/util/envutil" "github.com/cockroachdb/cockroach/pkg/util/leaktest" "github.com/cockroachdb/cockroach/pkg/util/log" @@ -191,10 +190,10 @@ func TestFilterGossipBootstrapResolvers(t *testing.T) { } cfg := MakeConfig(context.Background(), cluster.MakeTestingClusterSettings()) cfg.GossipBootstrapResolvers = resolvers + cfg.Addr = resolverSpecs[0] + cfg.AdvertiseAddr = resolverSpecs[2] - listenAddr := util.MakeUnresolvedAddr("tcp", resolverSpecs[0]) - advertAddr := util.MakeUnresolvedAddr("tcp", resolverSpecs[2]) - filtered := cfg.FilterGossipBootstrapResolvers(context.Background(), &listenAddr, &advertAddr) + filtered := cfg.FilterGossipBootstrapResolvers(context.Background()) if len(filtered) != 1 { t.Fatalf("expected one resolver; got %+v", filtered) } else if filtered[0].Addr() != resolverSpecs[1] { diff --git a/pkg/server/init.go b/pkg/server/init.go index 7c9b82eb7700..228afc025a95 100644 --- a/pkg/server/init.go +++ b/pkg/server/init.go @@ -13,10 +13,13 @@ package server import ( "context" "fmt" + "sync" + "time" "github.com/cockroachdb/cockroach/pkg/clusterversion" "github.com/cockroachdb/cockroach/pkg/config/zonepb" "github.com/cockroachdb/cockroach/pkg/gossip" + "github.com/cockroachdb/cockroach/pkg/gossip/resolver" "github.com/cockroachdb/cockroach/pkg/kv/kvserver" "github.com/cockroachdb/cockroach/pkg/roachpb" "github.com/cockroachdb/cockroach/pkg/server/serverpb" @@ -27,83 +30,85 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/syncutil" "github.com/cockroachdb/cockroach/pkg/util/uuid" "github.com/cockroachdb/errors" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + grpcstatus "google.golang.org/grpc/status" ) // ErrClusterInitialized is reported when the Bootstrap RPC is run on // a node that is already part of an initialized cluster. var ErrClusterInitialized = fmt.Errorf("cluster has already been initialized") +// ErrJoinRPCUnsupported is reported when the Join RPC is run against +// a node that does not know about the join RPC (i.e. it is running 20.1 or +// below). +// +// TODO(irfansharif): Remove this in 21.1. +var ErrJoinRPCUnsupported = fmt.Errorf("node does not support the Join RPC") + +// ErrIncompatibleBinaryVersion is returned when a CRDB node with a binary version X +// attempts to join a cluster with an active version that's higher. This is not +// allowed. +var ErrIncompatibleBinaryVersion = fmt.Errorf("binary is incompatible with the cluster attempted to join") + // initServer handles the bootstrapping process. It is instantiated early in the // server startup sequence to determine whether a NodeID and ClusterID are // available (true if and only if an initialized store is present). If all // engines are empty, either a new cluster needs to be started (via incoming -// Bootstrap RPC) or an existing one joined. Either way, the goal is to learn a -// ClusterID and NodeID (and initialize at least one store). All of this -// subtlety is encapsulated by the initServer, which offers a primitive -// ServeAndWait() after which point the startup code can assume that the -// Node/ClusterIDs are known. -// -// TODO(tbg): at the time of writing, when joining an existing cluster for the -// first time, the initServer provides only the clusterID. Fix this by giving -// the initServer a *kv.DB that it can use to assign a NodeID and StoreID, and -// later by switching to the connect RPC (#32574). +// Bootstrap RPC) or an existing one joined (via the outgoing Join RPC). Either +// way, the goal is to learn a ClusterID and NodeID (and initialize at least one +// store). All of this subtlety is encapsulated by the initServer, which offers +// a primitive ServeAndWait() after which point the startup code can assume that +// the Node/ClusterIDs are known. type initServer struct { + log.AmbientContext + // config houses a few configuration options needed by the init server. + config initServerCfg + mu struct { + // This mutex is grabbed during bootstrap and is used to serialized + // bootstrap attempts (and attempts to read whether or not his node has + // been bootstrapped). It's also used to guard inspectState below. syncutil.Mutex - // If set, a Bootstrap() call is rejected with this error. + + // The state of the engines. This tells us whether the node is already + // bootstrapped. The goal of the initServer is to stub this out by the time + // ServeAndWait returns. + inspectState *initDiskState + + // If we encounter an unrecognized error during bootstrap, we use this + // field to block out future bootstrap attempts. rejectErr error } - // The version at which to bootstrap the cluster in Bootstrap(). - bootstrapVersion roachpb.Version - // The zone configs to bootstrap with. - bootstrapZoneConfig, bootstrapSystemZoneConfig *zonepb.ZoneConfig - // The state of the engines. This tells us whether the node is already - // bootstrapped. The goal of the initServer is to complete this by the - // time ServeAndWait returns. - inspectState *initDiskState - - // If Bootstrap() succeeds, resulting initState will go here (to be consumed - // by ServeAndWait). + + // If this CRDB node was `cockroach init`-ialized, the resulting init state + // will be passed through to this channel. bootstrapReqCh chan *initState + // If this CRDB node was able to join a bootstrapped cluster, the resulting + // init state will be passed through to this channel. + joinCh chan *initState } -func setupInitServer( - ctx context.Context, - binaryVersion, binaryMinSupportedVersion roachpb.Version, - bootstrapVersion roachpb.Version, - bootstrapZoneConfig, bootstrapSystemZoneConfig *zonepb.ZoneConfig, - engines []storage.Engine, +func newInitServer( + actx log.AmbientContext, inspectState *initDiskState, config initServerCfg, ) (*initServer, error) { - inspectState, err := inspectEngines(ctx, engines, binaryVersion, binaryMinSupportedVersion) - if err != nil { - return nil, err - } - s := &initServer{ + AmbientContext: actx, bootstrapReqCh: make(chan *initState, 1), - - inspectState: inspectState, - bootstrapVersion: bootstrapVersion, - bootstrapZoneConfig: bootstrapZoneConfig, - bootstrapSystemZoneConfig: bootstrapSystemZoneConfig, + joinCh: make(chan *initState, 1), + config: config, } - - if len(inspectState.initializedEngines) > 0 { - // We have a NodeID/ClusterID, so don't allow bootstrap. - s.mu.rejectErr = ErrClusterInitialized - } - + s.mu.inspectState = inspectState return s, nil } // initDiskState contains the part of initState that is read from stable // storage. // -// TODO(tbg): the above is a lie in the case in which we join an existing +// NB: The above is a lie in the case in which we join an existing mixed-version // cluster. In that case, the state returned from ServeAndWait will have the -// clusterID set from Gossip (and there will be no NodeID). The plan is to -// allocate the IDs in ServeAndWait itself eventually, at which point the -// lie disappears. +// clusterID set from Gossip (and there will be no NodeID). This is holdover +// behavior that can be removed in 21.1, at which point the lie disappears. type initDiskState struct { // nodeID is zero if joining an existing cluster. // @@ -118,102 +123,226 @@ type initDiskState struct { // initState contains the cluster and node IDs as well as the stores, from which // a CockroachDB server can be started up after ServeAndWait returns. +// +// TODO(irfansharif): The usage of initState and then initDiskState is a bit +// confusing. It isn't the case today that the version held in memory for a +// running server will be wholly reconstructed if reloading from disk. It +// could if we always persisted any changes made to it back to disk. Right now +// when initializing after a successful join attempt, we don't persist back the +// disk state back to disk (we'd need to bootstrap the first store here, in the +// same we do when `cockroach init`-ialized). type initState struct { initDiskState + + firstStoreID roachpb.StoreID } -// NeedsInit returns true if (and only if) none if the engines are initialized. -// In this case, server startup is blocked until either an initialized node -// is reached via Gossip, or this node itself is bootstrapped. +// NeedsInit is like needsInitLocked, except it acquires the necessary locks. func (s *initServer) NeedsInit() bool { - return len(s.inspectState.initializedEngines) == 0 + s.mu.Lock() + defer s.mu.Unlock() + + return s.needsInitLocked() +} + +// needsInitLocked returns true if (and only if) none if the engines are +// initialized. In this case, ServeAndWait is blocked until either an +// initialized node is reached via the Join RPC (or Gossip if operating in mixed +// version clusters running v20.1, see ErrJoinUnimplemented), or this node +// itself is bootstrapped. +func (s *initServer) needsInitLocked() bool { + return len(s.mu.inspectState.initializedEngines) == 0 } -// ServeAndWait waits until the server is ready to bootstrap. In the common case -// of restarting an existing node, this immediately returns. When starting with -// a blank slate (i.e. only empty engines), it waits for incoming Bootstrap -// request or for Gossip to connect (whichever happens earlier). +// ServeAndWait waits until the server is initialized, i.e. has a cluster ID, +// node ID and has permission to join the cluster. In the common case of +// restarting an existing node, this immediately returns. When starting with a +// blank slate (i.e. only empty engines), it waits for incoming Bootstrap +// request or for a successful outgoing Join RPC, whichever happens earlier. +// See [1]. +// +// The returned initState reflects a bootstrapped cluster (i.e. it has a cluster +// ID and a node ID for this server). See [2]. +// +// This method must be called only once. // -// The returned initState may not reflect a bootstrapped cluster yet, but it -// is guaranteed to have a ClusterID set. -// initialStart is true if this is a new node. This flag should only be used for -// logging and reporting. A newly bootstrapped single-node cluster is, for e.g., +// NB: A gotcha that may not immediately be obvious is that we can never hope to +// have all stores initialized by the time ServeAndWait returns. This is because +// if this server is already bootstrapped, it might hold a replica of the range +// backing the StoreID allocating counter, and letting this server start may be +// necessary to restore quorum to that range. So in general, after this TODO, we +// will always leave this method with at least one store initialized, but not +// necessarily all. This is fine, since initializing additional stores later is +// easy. +// +// `initialBoot` is true if this is a new node. This flag should only be used +// for logging and reporting. A newly bootstrapped single-node cluster is // functionally equivalent to one that restarted; any decisions should be made // on persisted data instead of this flag. // -// This method must be called only once. +// [1]: In mixed version clusters it waits until Gossip connects (but this is +// slated to be removed in 21.1). // -// TODO(tbg): give this a KV client and thus initialize at least one store in -// all cases. +// [2]: This is not technically true for mixed version clusters where we leave +// the node ID unassigned until later, but this too is part of the deprecated +// init server behavior that is slated for removal in 21.1. func (s *initServer) ServeAndWait( - ctx context.Context, stopper *stop.Stopper, sv *settings.Values, g *gossip.Gossip, -) (state *initState, initialStart bool, err error) { - if !s.NeedsInit() { - // If already bootstrapped, return early. - return &initState{initDiskState: *s.inspectState}, false, nil + ctx context.Context, + stopper *stop.Stopper, + sv *settings.Values, + startGossipFn func() *gossip.Gossip, +) (state *initState, initialBoot bool, err error) { + // If already bootstrapped, return early. + s.mu.Lock() + if !s.needsInitLocked() { + diskState := *s.mu.inspectState + s.mu.Unlock() + + return &initState{initDiskState: diskState}, false, nil } + s.mu.Unlock() - log.Info(ctx, "no stores bootstrapped and --join flag specified, awaiting "+ - "init command or join with an already initialized node.") - - select { - case <-stopper.ShouldQuiesce(): - return nil, false, stop.ErrUnavailable - case state := <-s.bootstrapReqCh: - // Bootstrap() did its job. At this point, we know that the cluster - // version will be bootstrapVersion (=state.clusterVersion.Version), but - // the version setting does not know yet (it was initialized as - // BinaryMinSupportedVersion because the engines were all - // uninitialized). We *could* just let the server start, and it would - // populate system.settings, which is then gossiped, and then the - // callback would update the version, but we take this shortcut to avoid - // having every freshly bootstrapped cluster spend time at an old - // cluster version. - if err := clusterversion.Initialize(ctx, state.clusterVersion.Version, sv); err != nil { - return nil, false, err - } + log.Info(ctx, "no stores bootstrapped") + log.Info(ctx, "awaiting `cockroach init` or join with an already initialized node") + + joinCtx, cancelJoin := context.WithCancel(ctx) + defer cancelJoin() + + var wg sync.WaitGroup + wg.Add(1) + errCh := make(chan error, 1) + if err := stopper.RunTask(joinCtx, "init server: join loop", func(joinCtx context.Context) { + stopper.RunWorker(joinCtx, func(joinCtx context.Context) { + defer wg.Done() + + errCh <- s.startJoinLoop(joinCtx, stopper) + }) + }); err != nil { + return nil, false, err + } + + // gossipConnectedCh is used as a place holder for gossip.Connected. We + // don't trigger on gossip connectivity unless we have to, favoring instead + // the join RPC to discover the cluster ID (and node ID). If we're in a + // mixed-version cluster however (with 20.1 nodes), we'll fall back to using + // the legacy gossip connectivity mechanism to discover the cluster ID. + var gossipConnectedCh chan struct{} + var g *gossip.Gossip + + for { + select { + case state := <-s.bootstrapReqCh: + // Ensure we're draining out the join attempt. We're not going to + // need it anymore and it had no chance of joining anywhere (since + // we are starting the new cluster and are not serving Join yet). + cancelJoin() + wg.Wait() + + // Bootstrap() did its job. At this point, we know that the cluster + // version will be the bootstrap version (aka the binary version[1]), + // but the version setting does not know yet (it was initialized as + // BinaryMinSupportedVersion because the engines were all + // uninitialized). We *could* just let the server start, and it + // would populate system.settings, which is then gossiped, and then + // the callback would update the version, but we take this shortcut + // to avoid having every freshly bootstrapped cluster spend time at + // an old cluster version. + // + // [1]: See the top-level comment in pkg/clusterversion to make + // sense of the many versions of ...versions. + if err := clusterversion.Initialize(ctx, state.clusterVersion.Version, sv); err != nil { + return nil, false, err + } + + log.Infof(ctx, "cluster %s has been created", state.clusterID) + log.Infof(ctx, "allocated node ID: n%d (for self)", state.nodeID) + + s.mu.Lock() + s.mu.inspectState.clusterID = state.clusterID + s.mu.inspectState.initializedEngines = state.initializedEngines + s.mu.Unlock() + + return state, true, nil + case state := <-s.joinCh: + // Ensure we're draining out the join attempt. + wg.Wait() + <-errCh + + // TODO(irfansharif): We can try and initialize the the version + // setting to the active cluster version, in the same way we do when + // bootstrapping. We'd need to persis the cluster version to the + // engines here if we're looking to do so. + + log.Infof(ctx, "joined cluster %s through join rpc", state.clusterID) + log.Infof(ctx, "received node ID %d", state.nodeID) + + s.mu.Lock() + s.mu.inspectState.clusterID = state.clusterID + s.mu.Unlock() + + return state, true, nil + case <-gossipConnectedCh: + // Ensure we're draining out the join attempt. + wg.Wait() + + // We're in a mixed-version cluster, so we retain the legacy + // behavior of retrieving the cluster ID and deferring node ID + // allocation (happens in (*Node).start). + // + // TODO(irfansharif): Remove this in 21.1. + + // Gossip connected, that is, we know a ClusterID. Due to the early + // return above, we know that all of our engines are empty, i.e. we + // don't have a NodeID yet (and the cluster version is the minimum we + // support). Commence startup; the Node will realize it's short a + // NodeID and will request one. + clusterID, err := g.GetClusterID() + if err != nil { + return nil, false, err + } + + s.mu.Lock() + s.mu.inspectState.clusterID = clusterID + diskState := *s.mu.inspectState + s.mu.Unlock() + + state := &initState{ + initDiskState: diskState, + } + log.Infof(ctx, "joined cluster %s through gossip (legacy behavior)", state.clusterID) + return state, true, nil + case err := <-errCh: + // We won't return from here in the happy path; we'll let the join + // switch block do it for us. + + if errors.Is(err, ErrJoinRPCUnsupported) { + // We're in a mixed-version cluster, we start gossip and wire up + // the gossip connectivity mechanism to discover the cluster ID. + g = startGossipFn() + gossipConnectedCh = g.Connected + continue + } + + if errors.Is(err, ErrIncompatibleBinaryVersion) { + return nil, false, err + } - log.Infof(ctx, "**** cluster %s has been created", state.clusterID) - return state, true, nil - case <-g.Connected: - // Gossip connected, that is, we know a ClusterID. Due to the early - // return above, we know that all of our engines are empty, i.e. we - // don't have a NodeID yet (and the cluster version is the minimum we - // support). Commence startup; the Node will realize it's short a NodeID - // and will request one. - // - // TODO(tbg): use a kv.DB to get NodeID and StoreIDs when necessary and - // set everything up here. This will take the Node out of that business - // entirely and means we'll need much fewer NodeID/ClusterIDContainers. - // (It's also so much simpler to think about). The RPC will also tell us - // a cluster version to use instead of the lowest possible one (reducing - // the short amount of time until the Gossip hook bumps the version); - // this doesn't fix anything but again, is simpler to think about. A - // gotcha that may not immediately be obvious is that we can never hope - // to have all stores initialized by the time ServeAndWait returns. This - // is because *if this server is already bootstrapped*, it might hold a - // replica of the range backing the StoreID allocating counter, and - // letting this server start may be necessary to restore quorum to that - // range. So in general, after this TODO, we will always leave this - // method with *at least one* store initialized, but not necessarily - // all. This is fine, since initializing additional stores later is - // easy. - clusterID, err := g.GetClusterID() - if err != nil { - return nil, false, err + if err != nil { + log.Fatalf(ctx, "unexpected error: %s", err.Error()) + } + case <-stopper.ShouldQuiesce(): + return nil, false, stop.ErrUnavailable } - s.inspectState.clusterID = clusterID - return &initState{initDiskState: *s.inspectState}, true, nil } } var errInternalBootstrapError = errors.New("unable to bootstrap due to internal error") -// Bootstrap implements the serverpb.Init service. Users set up a new -// CockroachDB server by calling this endpoint on *exactly one node* in the -// cluster (retrying only on that node). -// Attempting to bootstrap a node that was already bootstrapped will result in -// an error. +// Bootstrap implements the serverpb.Init service. Users set up a new CRDB +// cluster by calling this endpoint on exactly one node in the cluster +// (typically retrying only on that node). This endpoint is what powers +// `cockroach init`. Attempting to bootstrap a node that was already +// bootstrapped will result in an `ErrClusterInitialized` error. // // NB: there is no protection against users erroneously bootstrapping multiple // nodes. In that case, they end up with more than one cluster, and nodes @@ -227,33 +356,206 @@ func (s *initServer) Bootstrap( s.mu.Lock() defer s.mu.Unlock() + if !s.needsInitLocked() { + return nil, ErrClusterInitialized + } + if s.mu.rejectErr != nil { return nil, s.mu.rejectErr } - state, err := s.tryBootstrap(ctx) + state, err := s.tryBootstrapLocked(ctx) if err != nil { log.Errorf(ctx, "bootstrap: %v", err) s.mu.rejectErr = errInternalBootstrapError return nil, s.mu.rejectErr } - s.mu.rejectErr = ErrClusterInitialized + s.bootstrapReqCh <- state return &serverpb.BootstrapResponse{}, nil } -func (s *initServer) tryBootstrap(ctx context.Context) (*initState, error) { - cv := clusterversion.ClusterVersion{Version: s.bootstrapVersion} - if err := kvserver.WriteClusterVersionToEngines(ctx, s.inspectState.newEngines, cv); err != nil { +// startJoinLoop continuously tries connecting to nodes specified in the join +// list in order to determine what the cluster ID is, and to be allocated a +// node+store ID. It can return ErrJoinRPCUnsupported, in which case the caller +// is expected to fall back to the gossip-based cluster ID discovery mechanism. +// It can also fail with ErrIncompatibleBinaryVersion, in which case we know we're +// running a binary that's too old to join the rest of the cluster. +func (s *initServer) startJoinLoop(ctx context.Context, stopper *stop.Stopper) error { + if len(s.config.resolvers) == 0 { + // We're pointing to only ourselves, which is probably indicative of a + // node that's going to be bootstrapped by the operator. We could opt to + // not fall back to the gossip based connectivity mechanism, but we do + // it anyway. + return ErrJoinRPCUnsupported + } + + const joinRPCBackoff = time.Second + var tickChan <-chan time.Time + { + ticker := time.NewTicker(joinRPCBackoff) + tickChan = ticker.C + defer ticker.Stop() + } + + for idx := 0; ; idx = (idx + 1) % len(s.config.resolvers) { + addr := s.config.resolvers[idx].Addr() + select { + case <-tickChan: + err := s.attemptJoin(ctx, addr) + if errors.Is(err, ErrJoinRPCUnsupported) || errors.Is(err, ErrIncompatibleBinaryVersion) { + // Propagate upwards; these are error conditions the caller + // knows to expect. + return err + } + + if err != nil { + // TODO(irfansharif): If startup logging gets too spammy, we + // could match against connection errors to generate nicer + // logging. See grpcutil.connectionRefusedRe. + + if IsWaitingForInit(err) { + log.Warningf(ctx, "%s is itself waiting for init, will retry", addr) + } else { + log.Warningf(ctx, "outgoing join rpc to %s unsuccessful: %v", addr, err.Error()) + } + + // Blindly retry on error. + continue + } + return nil + case <-ctx.Done(): + return nil + case <-stopper.ShouldQuiesce(): + return nil + } + } +} + +func (s *initServer) attemptJoin(ctx context.Context, addr string) error { + conn, err := grpc.DialContext(ctx, addr, s.config.dialOpts...) + if err != nil { + return err + } + + defer func() { + _ = conn.Close() + }() + + binaryVersion := s.config.binaryVersion + req := &roachpb.JoinNodeRequest{ + BinaryVersion: &binaryVersion, + } + + initClient := roachpb.NewInternalClient(conn) + resp, err := initClient.Join(ctx, req) + if err != nil { + // If the target node does not implement the Join RPC, or explicitly + // returns ErrJoinRPCUnsupported (because the cluster version + // introducing its usage is not yet active), we error out so the init + // server knows to fall back on the gossip-based discovery mechanism for + // the clusterID. + + status, ok := grpcstatus.FromError(errors.UnwrapAll(err)) + if !ok { + return err + } + + if status.Code() == codes.Unimplemented { + log.Infof(ctx, "%s running an older version; falling back to gossip-based cluster join", addr) + return ErrJoinRPCUnsupported + } + + if status.Code() == codes.PermissionDenied { + log.Infof(ctx, "%s is running a version higher than our binary version %s", addr, req.BinaryVersion.String()) + return ErrIncompatibleBinaryVersion + } + + return err + } + + clusterID, err := uuid.FromBytes(resp.ClusterID) + if err != nil { + return err + } + + s.mu.Lock() + s.mu.inspectState.clusterID = clusterID + s.mu.inspectState.nodeID = roachpb.NodeID(resp.NodeID) + s.mu.inspectState.clusterVersion = clusterversion.ClusterVersion{Version: *resp.ActiveVersion} + diskState := *s.mu.inspectState + s.mu.Unlock() + + state := &initState{ + initDiskState: diskState, + firstStoreID: roachpb.StoreID(resp.StoreID), + } + + s.joinCh <- state + return nil +} + +func (s *initServer) tryBootstrapLocked(ctx context.Context) (*initState, error) { + // We use our binary version to bootstrap the cluster. + cv := clusterversion.ClusterVersion{Version: s.config.binaryVersion} + if err := kvserver.WriteClusterVersionToEngines(ctx, s.mu.inspectState.newEngines, cv); err != nil { return nil, err } return bootstrapCluster( - ctx, s.inspectState.newEngines, s.bootstrapZoneConfig, s.bootstrapSystemZoneConfig, + ctx, s.mu.inspectState.newEngines, &s.config.defaultZoneConfig, &s.config.defaultSystemZoneConfig, ) } // DiskClusterVersion returns the cluster version synthesized from disk. This // is always non-zero since it falls back to the BinaryMinSupportedVersion. func (s *initServer) DiskClusterVersion() clusterversion.ClusterVersion { - return s.inspectState.clusterVersion + s.mu.Lock() + defer s.mu.Unlock() + + return s.mu.inspectState.clusterVersion +} + +// initServerCfg is a thin wrapper around the server Config object, exposing +// only the fields needed by the init server. +type initServerCfg struct { + advertiseAddr string + binaryMinSupportedVersion roachpb.Version + binaryVersion roachpb.Version + defaultSystemZoneConfig zonepb.ZoneConfig + defaultZoneConfig zonepb.ZoneConfig + + // dialOpts holds onto the dial options used when sending out Join RPCs. + dialOpts []grpc.DialOption + + // resolvers is a list of node addresses (populated using --join addresses) + // that is used to form a connected graph/network of CRDB servers. Once a + // strongly connected graph is constructed, it suffices for any node in the + // network to be initialized (which would then then propagates the cluster + // ID to the rest of the nodes). + // + // NB: Not that this does not work for weakly connected graphs. Let's + // consider a network where n3 points only to n2 (and not vice versa). If + // n2 is `cockroach init`-ialized, n3 will learn about it. The reverse will + // not be true. + resolvers []resolver.Resolver +} + +func newInitServerConfig(cfg Config, dialOpts []grpc.DialOption) initServerCfg { + binaryVersion := cfg.Settings.Version.BinaryVersion() + if knobs := cfg.TestingKnobs.Server; knobs != nil { + if ov := knobs.(*TestingKnobs).BootstrapVersionOverride; ov != (roachpb.Version{}) { + binaryVersion = ov + } + } + binaryMinSupportedVersion := cfg.Settings.Version.BinaryMinSupportedVersion() + resolvers := cfg.FilterGossipBootstrapResolvers(context.Background()) + return initServerCfg{ + advertiseAddr: cfg.AdvertiseAddr, + binaryMinSupportedVersion: binaryMinSupportedVersion, + binaryVersion: binaryVersion, + defaultSystemZoneConfig: cfg.DefaultSystemZoneConfig, + defaultZoneConfig: cfg.DefaultZoneConfig, + dialOpts: dialOpts, + resolvers: resolvers, + } } diff --git a/pkg/server/node.go b/pkg/server/node.go index 1c3eebdb3277..9cd686710ba2 100644 --- a/pkg/server/node.go +++ b/pkg/server/node.go @@ -49,6 +49,8 @@ import ( "github.com/cockroachdb/errors" "github.com/cockroachdb/logtags" opentracing "github.com/opentracing/opentracing-go" + "google.golang.org/grpc/codes" + grpcstatus "google.golang.org/grpc/status" ) const ( @@ -163,6 +165,8 @@ type Node struct { perReplicaServer kvserver.Server } +var _ roachpb.InternalServer = &Node{} + // allocateNodeID increments the node id generator key to allocate // a new, unique node id. func allocateNodeID(ctx context.Context, db *kv.DB) (roachpb.NodeID, error) { @@ -212,6 +216,7 @@ func bootstrapCluster( // TODO(andrei): It'd be cool if this method wouldn't do anything to engines // other than the first one, and let regular node startup code deal with them. var bootstrapVersion clusterversion.ClusterVersion + const firstStoreID = 1 for i, eng := range engines { cv, err := kvserver.ReadClusterVersion(ctx, eng) if err != nil { @@ -230,7 +235,7 @@ func bootstrapCluster( sIdent := roachpb.StoreIdent{ ClusterID: clusterID, NodeID: FirstNodeID, - StoreID: roachpb.StoreID(i + 1), + StoreID: roachpb.StoreID(i + firstStoreID), } // Initialize the engine backing the store with the store ident and cluster @@ -268,6 +273,7 @@ func bootstrapCluster( initializedEngines: engines, newEngines: nil, }, + firstStoreID: firstStoreID, } return state, nil } @@ -348,6 +354,10 @@ func (n *Node) start( n.initialStart = initialStart nodeID := state.nodeID if nodeID == 0 { + // TODO(irfansharif): This codepath exists to maintain the legacy + // behavior of node ID allocation that was triggered on gossip + // connectivity. This was replaced by the Join RPC in 20.2, and can be + // removed in 21.1. if !initialStart { log.Fatalf(ctx, "node has no NodeID, but claims to not be joining cluster") } @@ -450,7 +460,7 @@ func (n *Node) start( // TODO(tbg): address https://github.com/cockroachdb/cockroach/issues/39415. // Should be easy enough. Writing the test is probably most of the work. if len(state.newEngines) > 0 { - if err := n.bootstrapStores(ctx, state.newEngines, n.stopper); err != nil { + if err := n.bootstrapStores(ctx, state.firstStoreID, state.newEngines, n.stopper); err != nil { return err } } @@ -536,7 +546,10 @@ func (n *Node) validateStores(ctx context.Context) error { // allocated via a sequence id generator stored at a system key per // node. The new stores are added to n.stores. func (n *Node) bootstrapStores( - ctx context.Context, emptyEngines []storage.Engine, stopper *stop.Stopper, + ctx context.Context, + firstStoreID roachpb.StoreID, + emptyEngines []storage.Engine, + stopper *stop.Stopper, ) error { if n.clusterID.Get() == uuid.Nil { return errors.New("ClusterID missing during store bootstrap of auxiliary store") @@ -545,16 +558,28 @@ func (n *Node) bootstrapStores( { // Bootstrap all waiting stores by allocating a new store id for // each and invoking storage.Bootstrap() to persist it and the cluster - // version and to create stores. - inc := int64(len(emptyEngines)) - firstID, err := allocateStoreIDs(ctx, n.Descriptor.NodeID, inc, n.storeCfg.DB) + // version and to create stores. The -1 comes from the fact that our + // first store ID has already been pre-allocated for us. + storeIDAlloc := int64(len(emptyEngines)) - 1 + if firstStoreID == 0 { + // We lied, we don't have a firstStoreID; we'll need to allocate for + // that too. + // + // TODO(irfansharif): We get here if we're falling back to + // gossip-based connectivity. This can be removed in 21.1. + storeIDAlloc++ + } + startID, err := allocateStoreIDs(ctx, n.Descriptor.NodeID, storeIDAlloc, n.storeCfg.DB) + if firstStoreID == 0 { + firstStoreID = startID + } if err != nil { return errors.Errorf("error allocating store ids: %s", err) } sIdent := roachpb.StoreIdent{ ClusterID: n.clusterID.Get(), NodeID: n.Descriptor.NodeID, - StoreID: firstID, + StoreID: firstStoreID, } for _, eng := range emptyEngines { if err := kvserver.InitEngine(ctx, eng, sIdent); err != nil { @@ -1093,3 +1118,41 @@ func (n *Node) GossipSubscription( } } } + +// Join implements the roachpb.InternalServer service. This is the +// "connectivity" API; individual CRDB servers are passed in a --join list and +// the join targets are addressed through this API. +// +// TODO(irfansharif): Perhaps we could opportunistically create a liveness +// record here so as to no longer have to worry about the liveness record not +// existing for a given node. +func (n *Node) Join( + ctx context.Context, req *roachpb.JoinNodeRequest, +) (*roachpb.JoinNodeResponse, error) { + ctx, span := n.AnnotateCtxWithSpan(ctx, "alloc-{node,store}-id") + defer span.Finish() + + activeVersion := n.storeCfg.Settings.Version.ActiveVersion(ctx) + if req.BinaryVersion.Less(activeVersion.Version) { + return nil, grpcstatus.Error(codes.PermissionDenied, ErrIncompatibleBinaryVersion.Error()) + } + + nodeID, err := allocateNodeID(ctx, n.storeCfg.DB) + if err != nil { + return nil, err + } + + storeID, err := allocateStoreIDs(ctx, nodeID, 1, n.storeCfg.DB) + if err != nil { + return nil, err + } + + log.Infof(ctx, "allocated IDs: n%d, s%d", nodeID, storeID) + + return &roachpb.JoinNodeResponse{ + ClusterID: n.clusterID.Get().GetBytes(), + NodeID: int32(nodeID), + StoreID: int32(storeID), + ActiveVersion: &activeVersion.Version, + }, nil +} diff --git a/pkg/server/server.go b/pkg/server/server.go index 8a9dceb2d841..eacb34cac7b4 100644 --- a/pkg/server/server.go +++ b/pkg/server/server.go @@ -325,14 +325,14 @@ func NewServer(cfg Config, stopper *stop.Stopper) (*Server, error) { // and after ValidateAddrs(). rpcContext.CheckCertificateAddrs(ctx) - grpc := newGRPCServer(rpcContext) + grpcServer := newGRPCServer(rpcContext) g := gossip.New( cfg.AmbientCtx, &rpcContext.ClusterID, nodeIDContainer, rpcContext, - grpc.Server, + grpcServer.Server, stopper, registry, cfg.Locality, @@ -420,7 +420,7 @@ func NewServer(cfg Config, stopper *stop.Stopper) (*Server, error) { ) raftTransport := kvserver.NewRaftTransport( - cfg.AmbientCtx, st, nodeDialer, grpc.Server, stopper, + cfg.AmbientCtx, st, nodeDialer, grpcServer.Server, stopper, ) tsDB := ts.NewDB(db, cfg.Settings) @@ -521,9 +521,9 @@ func NewServer(cfg Config, stopper *stop.Stopper) (*Server, error) { storeCfg, recorder, registry, stopper, txnMetrics, nil /* execCfg */, &rpcContext.ClusterID) lateBoundNode = node - roachpb.RegisterInternalServer(grpc.Server, node) - kvserver.RegisterPerReplicaServer(grpc.Server, node.perReplicaServer) - node.storeCfg.ClosedTimestamp.RegisterClosedTimestampServer(grpc.Server) + roachpb.RegisterInternalServer(grpcServer.Server, node) + kvserver.RegisterPerReplicaServer(grpcServer.Server, node.perReplicaServer) + node.storeCfg.ClosedTimestamp.RegisterClosedTimestampServer(grpcServer.Server) replicationReporter := reports.NewReporter( db, node.stores, storePool, st, nodeLiveness, internalExecutor) @@ -566,7 +566,7 @@ func NewServer(cfg Config, stopper *stop.Stopper) (*Server, error) { if reflect.ValueOf(gw).IsNil() { return nil, errors.Errorf("%d: nil", i) } - gw.RegisterService(grpc.Server) + gw.RegisterService(grpcServer.Server) } var jobAdoptionStopFile string @@ -582,7 +582,7 @@ func NewServer(cfg Config, stopper *stop.Stopper) (*Server, error) { statusServer: serverpb.MakeOptionalStatusServer(sStatus), nodeLiveness: optionalnodeliveness.MakeContainer(nodeLiveness), gossip: gossip.MakeOptionalGossip(g), - grpcServer: grpc.Server, + grpcServer: grpcServer.Server, nodeIDContainer: idContainer, externalStorage: externalStorage, externalStorageFromURI: externalStorageFromURI, @@ -620,7 +620,7 @@ func NewServer(cfg Config, stopper *stop.Stopper) (*Server, error) { st: st, clock: clock, rpcContext: rpcContext, - grpc: grpc, + grpc: grpcServer, gossip: g, nodeDialer: nodeDialer, nodeLiveness: nodeLiveness, @@ -1055,27 +1055,34 @@ func (s *Server) Start(ctx context.Context) error { blobs.NewBlobClientFactory(s.nodeIDContainer.Get(), s.nodeDialer, s.st.ExternalIODir), &fileTableInternalExecutor, s.db) - bootstrapVersion := s.cfg.Settings.Version.BinaryVersion() - if knobs := s.cfg.TestingKnobs.Server; knobs != nil { - if ov := knobs.(*TestingKnobs).BootstrapVersionOverride; ov != (roachpb.Version{}) { - bootstrapVersion = ov - } - } + // Filter out self from the gossip bootstrap resolvers. + filtered := s.cfg.FilterGossipBootstrapResolvers(ctx) // Set up the init server. We have to do this relatively early because we // can't call RegisterInitServer() after `grpc.Serve`, which is called in // startRPCServer (and for the loopback grpc-gw connection). - initServer, err := setupInitServer( - ctx, - s.cfg.Settings.Version.BinaryVersion(), - s.cfg.Settings.Version.BinaryMinSupportedVersion(), - bootstrapVersion, - &s.cfg.DefaultZoneConfig, - &s.cfg.DefaultSystemZoneConfig, - s.engines, - ) - if err != nil { - return err + var initServer *initServer + { + dialOpts, err := s.rpcContext.GRPCDialOptions() + if err != nil { + return err + } + + initConfig := newInitServerConfig(s.cfg, dialOpts) + inspectState, err := inspectEngines( + ctx, + s.engines, + s.cfg.Settings.Version.BinaryVersion(), + s.cfg.Settings.Version.BinaryMinSupportedVersion(), + ) + if err != nil { + return err + } + + initServer, err = newInitServer(s.cfg.AmbientCtx, inspectState, initConfig) + if err != nil { + return err + } } { @@ -1266,16 +1273,37 @@ func (s *Server) Start(ctx context.Context) error { } } - // Filter the gossip bootstrap resolvers based on the listen and - // advertise addresses. - listenAddrU := util.NewUnresolvedAddr("tcp", s.cfg.Addr) + // NB: This needs to come after `startListenRPCAndSQL`, which determines + // what the advertised addr is going to be if nothing is explicitly + // provided. advAddrU := util.NewUnresolvedAddr("tcp", s.cfg.AdvertiseAddr) - advSQLAddrU := util.NewUnresolvedAddr("tcp", s.cfg.SQLAdvertiseAddr) - filtered := s.cfg.FilterGossipBootstrapResolvers(ctx, listenAddrU, advAddrU) - s.gossip.Start(advAddrU, filtered) - log.Event(ctx, "started gossip") + // As of 21.1, we will no longer need gossip to start before the init + // server. We need it in 20.2 for backwards compatibility with 20.1 servers + // that use gossip connectivity to distribute the cluster ID. In 20.2 we + // introduced a dedicated Join RPC to do exactly this, and so we can defer + // gossip start to after bootstrap/initialization. + // + // In order to defer starting gossip until absolutely needed, we wrap up + // gossip start in an idempotent function that's provided to the init + // server. It'll get invoked if we detect we're in a mixed-version cluster. + // If we're starting off at 20.2, we'll start gossip later. + // + // TODO(irfansharif): Remove this callback in 21.1. + var startGossipFn func() *gossip.Gossip + { + var once sync.Once + startGossipFn = func() *gossip.Gossip { + once.Do(func() { + s.gossip.Start(advAddrU, filtered) + log.Event(ctx, "started gossip") + }) + return s.gossip + } + } + // TODO(irfansharif): How late can we defer gossip start to? + startGossipFn() if s.cfg.DelayedBootstrapFn != nil { defer time.AfterFunc(30*time.Second, s.cfg.DelayedBootstrapFn).Stop() } @@ -1287,8 +1315,6 @@ func (s *Server) Start(ctx context.Context) error { if _, err := initServer.Bootstrap(ctx, &serverpb.BootstrapRequest{}); err != nil { return err } - } else { - log.Info(ctx, "awaiting init command or join with an already initialized node.") } // Set up calling s.cfg.ReadyFn at the right time. Essentially, this call @@ -1312,12 +1338,12 @@ func (s *Server) Start(ctx context.Context) error { } // This opens the main listener. When the listener is open, we can call - // initServerReadyFn since any request initiated to the initServer at that - // point will reach it once ServeAndWait starts handling the queue of incoming - // connections. + // onInitServerReady since any request initiated to the initServer at that + // point will reach it once ServeAndWait starts handling the queue of + // incoming connections. startRPCServer(workersCtx) onInitServerReady() - state, initialStart, err := initServer.ServeAndWait(ctx, s.stopper, &s.cfg.Settings.SV, s.gossip) + state, initialStart, err := initServer.ServeAndWait(ctx, s.stopper, &s.cfg.Settings.SV, startGossipFn) if err != nil { return errors.Wrap(err, "during init") } @@ -1325,6 +1351,9 @@ func (s *Server) Start(ctx context.Context) error { s.rpcContext.ClusterID.Set(ctx, state.clusterID) // If there's no NodeID here, then we didn't just bootstrap. The Node will // read its ID from the stores or request a new one via KV. + // + // TODO(irfansharif): Make this unconditional once 20.2 is cut. This only + // exists to be compatible with 20.1 clusters. if state.nodeID != 0 { s.rpcContext.NodeID.Set(ctx, state.nodeID) } @@ -1354,7 +1383,7 @@ func (s *Server) Start(ctx context.Context) error { // demonstrate that we're not doing anything functional here (and to // prevent bugs during further refactors). if s.rpcContext.ClusterID.Get() == uuid.Nil { - return errors.New("gossip should already be connected") + return errors.AssertionFailedf("expected cluster ID to be populated in rpc context") } unregister := s.gossip.RegisterCallback(gossip.KeyClusterID, func(string, roachpb.Value) { clusterID, err := s.gossip.GetClusterID() @@ -1411,6 +1440,7 @@ func (s *Server) Start(ctx context.Context) error { // Now that we have a monotonic HLC wrt previous incarnations of the process, // init all the replicas. At this point *some* store has been bootstrapped or // we're joining an existing cluster for the first time. + advSQLAddrU := util.NewUnresolvedAddr("tcp", s.cfg.SQLAdvertiseAddr) if err := s.node.start( ctx, advAddrU, diff --git a/pkg/server/serverpb/init.pb.go b/pkg/server/serverpb/init.pb.go index 6a132146a2c6..55021d9024fa 100644 --- a/pkg/server/serverpb/init.pb.go +++ b/pkg/server/serverpb/init.pb.go @@ -32,7 +32,7 @@ func (m *BootstrapRequest) Reset() { *m = BootstrapRequest{} } func (m *BootstrapRequest) String() string { return proto.CompactTextString(m) } func (*BootstrapRequest) ProtoMessage() {} func (*BootstrapRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_init_5d06be670cd568de, []int{0} + return fileDescriptor_init_119a86c40b8bcd78, []int{0} } func (m *BootstrapRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -64,7 +64,7 @@ func (m *BootstrapResponse) Reset() { *m = BootstrapResponse{} } func (m *BootstrapResponse) String() string { return proto.CompactTextString(m) } func (*BootstrapResponse) ProtoMessage() {} func (*BootstrapResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_init_5d06be670cd568de, []int{1} + return fileDescriptor_init_119a86c40b8bcd78, []int{1} } func (m *BootstrapResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -106,7 +106,10 @@ const _ = grpc.SupportPackageIsVersion4 // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type InitClient interface { - // Bootstrap an uninitialized cluster. + // Bootstrap bootstraps an uninitialized cluster. This is primarily used by + // cockroach init. It writes the data for a single-node cluster comprised of + // this node (with NodeID "1") to the first store (StoreID "1"), after which + // the node can start and allow other nodes to join the cluster. Bootstrap(ctx context.Context, in *BootstrapRequest, opts ...grpc.CallOption) (*BootstrapResponse, error) } @@ -129,7 +132,10 @@ func (c *initClient) Bootstrap(ctx context.Context, in *BootstrapRequest, opts . // InitServer is the server API for Init service. type InitServer interface { - // Bootstrap an uninitialized cluster. + // Bootstrap bootstraps an uninitialized cluster. This is primarily used by + // cockroach init. It writes the data for a single-node cluster comprised of + // this node (with NodeID "1") to the first store (StoreID "1"), after which + // the node can start and allow other nodes to join the cluster. Bootstrap(context.Context, *BootstrapRequest) (*BootstrapResponse, error) } @@ -449,9 +455,9 @@ var ( ErrIntOverflowInit = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("server/serverpb/init.proto", fileDescriptor_init_5d06be670cd568de) } +func init() { proto.RegisterFile("server/serverpb/init.proto", fileDescriptor_init_119a86c40b8bcd78) } -var fileDescriptor_init_5d06be670cd568de = []byte{ +var fileDescriptor_init_119a86c40b8bcd78 = []byte{ // 173 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2a, 0x4e, 0x2d, 0x2a, 0x4b, 0x2d, 0xd2, 0x87, 0x50, 0x05, 0x49, 0xfa, 0x99, 0x79, 0x99, 0x25, 0x7a, 0x05, 0x45, 0xf9, diff --git a/pkg/server/serverpb/init.proto b/pkg/server/serverpb/init.proto index 491115f9a502..9e8e83255ebd 100644 --- a/pkg/server/serverpb/init.proto +++ b/pkg/server/serverpb/init.proto @@ -12,14 +12,13 @@ syntax = "proto3"; package cockroach.server.serverpb; option go_package = "serverpb"; -message BootstrapRequest { -} - -message BootstrapResponse { -} +message BootstrapRequest { } +message BootstrapResponse { } service Init { - // Bootstrap an uninitialized cluster. - rpc Bootstrap(BootstrapRequest) returns (BootstrapResponse) { - } + // Bootstrap bootstraps an uninitialized cluster. This is primarily used by + // cockroach init. It writes the data for a single-node cluster comprised of + // this node (with NodeID "1") to the first store (StoreID "1"), after which + // the node can start and allow other nodes to join the cluster. + rpc Bootstrap(BootstrapRequest) returns (BootstrapResponse) { } } diff --git a/pkg/server/status.go b/pkg/server/status.go index f5b3534bec9f..d9c600232d66 100644 --- a/pkg/server/status.go +++ b/pkg/server/status.go @@ -224,7 +224,7 @@ func (s *statusServer) parseNodeID(nodeIDParam string) (roachpb.NodeID, bool, er id, err := strconv.ParseInt(nodeIDParam, 0, 32) if err != nil { - return 0, false, errors.Wrap(err, "node id could not be parsed") + return 0, false, errors.Wrap(err, "node ID could not be parsed") } nodeID := roachpb.NodeID(id) return nodeID, nodeID == s.gossip.NodeID.Get(), nil