diff --git a/.gitignore b/.gitignore index 4642f4e8e..275a8ade8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,9 @@ +.vscode/ +Release/ +Debug/ +datasets/ +build/ +data/ # Prerequisites *.d diff --git a/AnnService/inc/Core/Common/QueryResultSet.h b/AnnService/inc/Core/Common/QueryResultSet.h index 35fc9b554..25975161a 100644 --- a/AnnService/inc/Core/Common/QueryResultSet.h +++ b/AnnService/inc/Core/Common/QueryResultSet.h @@ -4,9 +4,12 @@ #ifndef _SPTAG_COMMON_QUERYRESULTSET_H_ #define _SPTAG_COMMON_QUERYRESULTSET_H_ +#include "inc/Core/Common.h" +#include "inc/Core/CommonDataStructure.h" #include "inc/Core/SearchQuery.h" #include "DistanceUtils.h" #include +#include #include "IQuantizer.h" namespace SPTAG @@ -36,9 +39,19 @@ class QueryResultSet : public QueryResult } QueryResultSet(const QueryResultSet& other) : QueryResult(other) - { + { } + // QueryResultSet(const T*_target, int _K, bool _withResult) { + // m_withResultVector = _withResult; + // if(m_withResultVector) { + // m_resultVectors.resize(_K); + // } + // for(auto& ptr : m_resultVectors) { + // ptr = std::shared_ptr(new T(), [](T* p) { delete p; }); + // } + // } + ~QueryResultSet() { } @@ -86,11 +99,46 @@ class QueryResultSet : public QueryResult return false; } + // bool NeedResultVector() const { + // return m_withResultVector; + // } + + // void RemoveResultVector() { + // if(m_withResultVector) { + // m_withResultVector = false; + // m_resultVectors.clear(); + // } + // } + + // if we want to use spread search, the query result should be copied to the result set + bool AddPoint(const SizeType index, float dist, ByteArray& vector) { + if (dist < m_results[0].Dist || (dist == m_results[0].Dist && index < m_results[0].VID)) + { + m_results[0].VID = index; + m_results[0].Dist = dist; + m_results[0].Vector = vector; + // if(data != nullptr) // && m_withResultVector) + // { + // // copy data to m_resultVectors[0] + // // since we have already allocated memory for each result vector, we can directly copy data to it + // // memcpy(m_resultVectors[0].get(), data, sizeof(T)); + // memcpy() + // } + Heapify(m_resultNum); + return true; + } + return false; + } + inline void SortResult() { for (int i = m_resultNum - 1; i >= 0; i--) { std::swap(m_results[0], m_results[i]); + // if(m_withResultVector) + // { + // std::swap(m_resultVectors[0], m_resultVectors[i]); + // } Heapify(i); } } @@ -100,6 +148,17 @@ class QueryResultSet : public QueryResult std::reverse(m_results.Data(), m_results.Data() + m_resultNum); } + // std::shared_ptr GetVector(int idx) const + // { + // if (idx < m_resultNum) return m_resultVectors[idx]; + // return nullptr; + // } + ByteArray GetVector(int idx) const + { + if (idx < m_resultNum) return m_results[idx].Vector; + return ByteArray(); + } + private: void Heapify(int count) { @@ -110,15 +169,30 @@ class QueryResultSet : public QueryResult if (m_results[parent] < m_results[next]) { std::swap(m_results[next], m_results[parent]); + // if(m_withResultVector) + // { + // std::swap(m_resultVectors[next], m_resultVectors[parent]); + // } parent = next; next = (parent << 1) + 1; } else break; } - if (next == maxidx && m_results[parent] < m_results[next]) std::swap(m_results[parent], m_results[next]); + if (next == maxidx && m_results[parent] < m_results[next]) + { + std::swap(m_results[parent], m_results[next]); + // if(m_withResultVector) + // { + // std::swap(m_resultVectors[parent], m_resultVectors[next]); + // } + } } + + // bool m_withResultVector = false; + // std::vector> m_resultVectors; }; } } + #endif // _SPTAG_COMMON_QUERYRESULTSET_H_ diff --git a/AnnService/inc/Core/SPANN/ExtraFullGraphSearcher.h b/AnnService/inc/Core/SPANN/ExtraFullGraphSearcher.h index 0b84f0167..895ac3754 100644 --- a/AnnService/inc/Core/SPANN/ExtraFullGraphSearcher.h +++ b/AnnService/inc/Core/SPANN/ExtraFullGraphSearcher.h @@ -4,6 +4,7 @@ #ifndef _SPTAG_SPANN_EXTRASEARCHER_H_ #define _SPTAG_SPANN_EXTRASEARCHER_H_ +#include "inc/Core/CommonDataStructure.h" #include "inc/Helper/VectorSetReader.h" #include "inc/Helper/AsyncFileReader.h" #include "IExtraSearcher.h" @@ -125,7 +126,9 @@ namespace SPTAG if (p_exWorkSpace->m_deduper.CheckAndSet(vectorID)) continue; \ (this->*m_parseEncoding)(p_index, listInfo, (ValueType*)(p_postingListFullData + offsetVector));\ auto distance2leaf = p_index->ComputeDistance(queryResults.GetQuantizedTarget(), p_postingListFullData + offsetVector); \ - queryResults.AddPoint(vectorID, distance2leaf); \ + SPTAG::ByteArray tmpVector = SPTAG::ByteArray::Alloc(sizeof(ValueType)* (m_vectorInfoSize - sizeof(int))); \ + memcpy(tmpVector.Data(), p_postingListFullData + offsetVector, sizeof(ValueType)* (m_vectorInfoSize - sizeof(int))); \ + queryResults.AddPoint(vectorID, distance2leaf, tmpVector); \ } \ #define ProcessPostingOffset() \ @@ -137,7 +140,9 @@ namespace SPTAG if (p_exWorkSpace->m_deduper.CheckAndSet(vectorID)) continue; \ (this->*m_parseEncoding)(p_index, listInfo, (ValueType*)(p_postingListFullData + offsetVector));\ auto distance2leaf = p_index->ComputeDistance(queryResults.GetQuantizedTarget(), p_postingListFullData + offsetVector); \ - queryResults.AddPoint(vectorID, distance2leaf); \ + SPTAG::ByteArray tmpVector = SPTAG::ByteArray::Alloc(sizeof(ValueType)* (m_vectorInfoSize - sizeof(int))); \ + memcpy(tmpVector.Data(), p_postingListFullData + offsetVector, sizeof(ValueType)* (m_vectorInfoSize - sizeof(int))); \ + queryResults.AddPoint(vectorID, distance2leaf, tmpVector);\ foundResult = true;\ break;\ } \ diff --git a/AnnService/inc/Core/SPANN/IExtraSearcher.h b/AnnService/inc/Core/SPANN/IExtraSearcher.h index 064fbfcac..904a9d996 100644 --- a/AnnService/inc/Core/SPANN/IExtraSearcher.h +++ b/AnnService/inc/Core/SPANN/IExtraSearcher.h @@ -8,6 +8,7 @@ #include "inc/Core/VectorIndex.h" #include "inc/Helper/AsyncFileReader.h" +#include "inc/Helper/VectorSetReader.h" #include #include @@ -229,6 +230,7 @@ namespace SPTAG { virtual bool CheckValidPosting(SizeType postingID) = 0; virtual ErrorCode GetPostingDebug(ExtraWorkSpace* p_exWorkSpace, std::shared_ptr p_index, SizeType vid, std::vector& VIDs, std::shared_ptr& vecs) = 0; + }; } // SPANN } // SPTAG diff --git a/AnnService/inc/Core/SPANN/Index.h b/AnnService/inc/Core/SPANN/Index.h index 15ed7d4ee..00ccc0bb2 100644 --- a/AnnService/inc/Core/SPANN/Index.h +++ b/AnnService/inc/Core/SPANN/Index.h @@ -141,6 +141,7 @@ namespace SPTAG ErrorCode SearchDiskIndex(QueryResult& p_query, SearchStats* p_stats = nullptr) const; bool SearchDiskIndexIterative(QueryResult& p_headQuery, QueryResult& p_query, ExtraWorkSpace* extraWorkspace) const; + ErrorCode SearchDoc2Doc(QueryResult &p_query, COMMON::QueryResultSet* p_results, std::unique_ptr workSpace) const; ErrorCode DebugSearchDiskIndex(QueryResult& p_query, int p_subInternalResultNum, int p_internalResultNum, SearchStats* p_stats = nullptr, std::set* truth = nullptr, std::map>* found = nullptr) const; ErrorCode UpdateIndex(); diff --git a/AnnService/inc/Core/SPANN/Options.h b/AnnService/inc/Core/SPANN/Options.h index 443508f32..6f29e86b0 100644 --- a/AnnService/inc/Core/SPANN/Options.h +++ b/AnnService/inc/Core/SPANN/Options.h @@ -122,6 +122,9 @@ namespace SPTAG { int m_debugBuildInternalResultNum; bool m_enableADC; int m_iotimeout; + bool m_spreadSearch; + int m_doc2docRounds; + int m_doc2docResults; // Iterative int m_headBatch; diff --git a/AnnService/inc/Core/SPANN/ParameterDefinitionList.h b/AnnService/inc/Core/SPANN/ParameterDefinitionList.h index a9068d91d..ca407abf0 100644 --- a/AnnService/inc/Core/SPANN/ParameterDefinitionList.h +++ b/AnnService/inc/Core/SPANN/ParameterDefinitionList.h @@ -120,7 +120,9 @@ DefineSSDParameter(m_enableADC, bool, false, "EnableADC") DefineSSDParameter(m_recall_analysis, bool, false, "RecallAnalysis") DefineSSDParameter(m_debugBuildInternalResultNum, int, 64, "DebugBuildInternalResultNum") DefineSSDParameter(m_iotimeout, int, 30, "IOTimeout") - +DefineSSDParameter(m_spreadSearch, bool, true, "SpreadSearch") +DefineSSDParameter(m_doc2docRounds, int, 2, "doc2docRounds") +DefineSSDParameter(m_doc2docResults, int, 32, "Doc2DocResults") // Iterative DefineSSDParameter(m_headBatch, int, 32, "IterativeSearchHeadBatch") diff --git a/AnnService/inc/Core/SearchResult.h b/AnnService/inc/Core/SearchResult.h index 8c458fe3b..d356474e5 100644 --- a/AnnService/inc/Core/SearchResult.h +++ b/AnnService/inc/Core/SearchResult.h @@ -5,6 +5,8 @@ #define _SPTAG_SEARCHRESULT_H_ #include "CommonDataStructure.h" +#include "inc/Core/Common.h" +#include namespace SPTAG { @@ -67,6 +69,7 @@ namespace SPTAG SizeType VID; float Dist; ByteArray Meta; + ByteArray Vector; bool RelaxedMono; BasicResult() : VID(-1), Dist(MaxDist), RelaxedMono(false) {} @@ -75,6 +78,8 @@ namespace SPTAG BasicResult(SizeType p_vid, float p_dist, ByteArray p_meta) : VID(p_vid), Dist(p_dist), Meta(p_meta), RelaxedMono(false) {} BasicResult(SizeType p_vid, float p_dist, ByteArray p_meta, bool p_relaxedMono) : VID(p_vid), Dist(p_dist), Meta(p_meta), RelaxedMono(p_relaxedMono) {} + BasicResult(SizeType p_vid, float p_dist, ByteArray p_meta, ByteArray p_vector) : VID(p_vid), Dist(p_dist), Meta(p_meta), Vector(p_vector), RelaxedMono(false) {} + BasicResult(SizeType p_vid, float p_dist, ByteArray p_meta, ByteArray p_vector, bool p_relaxedMono) : VID(p_vid), Dist(p_dist), Meta(p_meta), Vector(p_vector), RelaxedMono(p_relaxedMono) {} }; } // namespace SPTAG diff --git a/AnnService/src/Core/SPANN/SPANNIndex.cpp b/AnnService/src/Core/SPANN/SPANNIndex.cpp index aecd3ac23..88a017f2f 100644 --- a/AnnService/src/Core/SPANN/SPANNIndex.cpp +++ b/AnnService/src/Core/SPANN/SPANNIndex.cpp @@ -1,10 +1,17 @@ // Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. +#include "inc/Core/Common.h" +#include "inc/Core/CommonDataStructure.h" +#include "inc/Core/SPANN/IExtraSearcher.h" #include "inc/Core/SPANN/Index.h" #include "inc/Helper/VectorSetReaders/MemoryReader.h" #include "inc/Core/SPANN/ExtraFullGraphSearcher.h" #include +#include +#include +#include +#include #include "inc/Core/ResultIterator.h" #include "inc/Core/SPANN/SPANNResultIterator.h" #pragma warning(disable:4242) // '=' : conversion from 'int' to 'short', possible loss of data @@ -199,9 +206,11 @@ namespace SPTAG p_queryResults = (COMMON::QueryResultSet*) & p_query; else p_queryResults = new COMMON::QueryResultSet((const T*)p_query.GetTarget(), m_options.m_searchInternalResultNum); - + // p_queryResults = new COMMON::QueryResultSet((const T*)p_query.GetTarget(), m_options.m_searchInternalResultNum); + // auto t1 = std::chrono::high_resolution_clock::now(); m_index->SearchIndex(*p_queryResults); - + [[maybe_unused]] int visited_postings = 0; + // std::set searchedPostingIDs; if (m_extraSearcher != nullptr) { auto workSpace = m_workSpaceFactory->GetWorkSpace(); if (!workSpace) { @@ -221,7 +230,15 @@ namespace SPTAG if (res->VID == -1) break; auto postingID = res->VID; + // if (res->Vector.Data() == nullptr) { + // we should find this vector in the m_index + res->Vector = ByteArray::Alloc(m_index->GetFeatureDim() * sizeof(T)); + auto tmp = m_index->GetSample(res->VID); + std::memcpy(res->Vector.Data(), tmp, m_index->GetFeatureDim() * sizeof(T)); + // } + // SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "PostingID: %d\n", postingID); res->VID = static_cast((m_vectorTranslateMap.get())[res->VID]); + // SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "VID: %d\n", res->VID); if (res->VID == MaxSize) { res->VID = -1; res->Dist = MaxDist; @@ -232,12 +249,26 @@ namespace SPTAG (limitDist > 0.1 && res->Dist > limitDist) || !m_extraSearcher->CheckValidPosting(postingID)) continue; + ++visited_postings; workSpace->m_postingIDs.emplace_back(postingID); } + // record searchedd postings, if we want to conduct doc2doc search we should avoid visiting them again + // searchedPostingIDs.insert(workSpace->m_postingIDs.begin(), workSpace->m_postingIDs.end()); p_queryResults->Reverse(); m_extraSearcher->SearchIndex(workSpace.get(), *p_queryResults, m_index, nullptr); - m_workSpaceFactory->ReturnWorkSpace(std::move(workSpace)); + if(!m_options.m_spreadSearch) + { + m_workSpaceFactory->ReturnWorkSpace(std::move(workSpace)); + } + else + { + // We may need to do doc2doc search search, so don't sort the result here + // Instead we put it after the doc2doc search stage + + // Use this workspace for doc2doc round, so don't return it + SearchDoc2Doc(p_query, p_queryResults, std::move(workSpace)); + } p_queryResults->SortResult(); } @@ -257,6 +288,115 @@ namespace SPTAG return ErrorCode::Success; } + template + ErrorCode Index::SearchDoc2Doc(QueryResult &p_query, COMMON::QueryResultSet* p_queryResults, std::unique_ptr workSpace) const { + // Use this set to store the visited posting ids, avoid visiting them again + std::unordered_set visited(workSpace->m_postingIDs.begin(), workSpace->m_postingIDs.end()); + // Run doc2doc search for multiple rounds + for (int d = 0; d < m_options.m_doc2docRounds; ++d) { + // Store the doc2doc searched postings in this set + auto p_queryIntermediateResults = new COMMON::QueryResultSet((const T*)p_query.GetTarget(), m_options.m_searchInternalResultNum); + workSpace->m_postingIDs.clear(); + // Search doc2docResults number of new centroids for each centroid in the previous round + auto p_newResultsToQuery = new COMMON::QueryResultSet((const T*)p_query.GetTarget(), min(m_options.m_doc2docResults, p_queryResults->GetResultNum())); + for (int i = 0; i < p_newResultsToQuery->GetResultNum(); ++i) { + p_newResultsToQuery->GetResult(i)->VID = -1; + p_newResultsToQuery->GetResult(i)->Dist = MaxDist; + } + p_queryResults->SortResult(); + std::set skippedIdx; + for (auto i = 0; i < min(m_options.m_doc2docResults, p_queryResults->GetResultNum()); ++i) { + auto res = p_queryResults->GetResult(i); + // Use this res to build a new query to search on m_index + if (res->VID == -1) break; + bool goodRNG = true; + for (int k = 0; k < i; ++k) { + // apply rng rule to filter out closed intermidiate results + if (skippedIdx.find(k) == skippedIdx.end() + && m_options.m_rngFactor * m_fComputeDistance((const T*)p_queryResults->GetVector(k).Data(), (const T*)res->Vector.Data(), m_index->GetFeatureDim()) < res->Dist) { + goodRNG = false; + skippedIdx.insert(i); + break; + } + } + if (!goodRNG) continue; + + p_queryIntermediateResults->SetTarget((const T*)res->Vector.Data(), nullptr); + m_index->SearchIndex(*p_queryIntermediateResults); + + float limitDist = p_queryIntermediateResults->GetResult(0)->Dist * m_options.m_maxDistRatio; + int foundDocs = 0; + for (int j = 0; j < p_queryIntermediateResults->GetResultNum(); ++j) + { + auto res = p_queryIntermediateResults->GetResult(j); + if (res->VID == -1) break; + + auto postingID = res->VID; + + res->VID = static_cast((m_vectorTranslateMap.get())[res->VID]); + if (res->VID == MaxSize) { + res->VID = -1; + res->Dist = MaxDist; + } + + // Don't do disk reads for irrelevant pages + if (workSpace->m_postingIDs.size() >= m_options.m_searchInternalResultNum || + (limitDist > 0.1 && res->Dist > limitDist) || + !m_extraSearcher->CheckValidPosting(postingID)) + continue; + // Don't visit the same posting again + if (visited.find(postingID) != visited.end()) continue; + + // Priviously the distance is the distance to the intermediate query + // Replace the distance with the distance to the original query + res->Dist = m_fComputeDistance((const T*)m_index->GetSample(postingID), (const T*)p_query.GetTarget(), m_index->GetFeatureDim()); + + // Add the new centroid to the new results to query, + // Increase the foundDocs count if the centroid is added successfully + if(p_newResultsToQuery->AddPoint(postingID, res->Dist)) { + ++foundDocs; + } + visited.insert(postingID); + } + // If we found less than 2 new centroids, stop the current round + if(foundDocs <= 2) break; + + p_queryIntermediateResults->Reset(); + } + for(int i = 0; i < p_newResultsToQuery->GetResultNum(); ++i) { + if (p_newResultsToQuery->GetResult(i)->VID == -1) break; + + workSpace->m_postingIDs.emplace_back(p_newResultsToQuery->GetResult(i)->VID); + } + + p_queryResults->Reverse(); + + std::set oldResults; + for (int i = 0; i < p_queryResults->GetResultNum(); ++i) { + if(p_queryResults->GetResult(i)->VID == -1) break; + oldResults.insert(p_queryResults->GetResult(i)->VID); + + } + m_extraSearcher->SearchIndex(workSpace.get(), *p_queryResults, m_index, nullptr); + int foundNewNNCount = 0; + // Count the number of new NNs found in this doc2doc round + for (int i = 0; i < p_queryResults->GetResultNum(); ++i) { + if(p_queryResults->GetResult(i)->VID == -1) break; + if(oldResults.find(p_queryResults->GetResult(i)->VID) == oldResults.end()) { + ++foundNewNNCount; + } + } + // SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Found %d new NNs in round %d from %d new centroids\n", foundNewNNCount, d, workSpace->m_postingIDs.size()); + delete p_queryIntermediateResults; + delete p_newResultsToQuery; + // If we cannot find more new NNs, stop the doc2doc search + if(foundNewNNCount == 0) break; + if (workSpace->m_postingIDs.size() == 0) break; + } + m_workSpaceFactory->ReturnWorkSpace(std::move(workSpace)); + return ErrorCode::Success; + } + template ErrorCode Index::SearchIndexIterative(QueryResult& p_headQuery, QueryResult& p_query, COMMON::WorkSpace* p_indexWorkspace, diff --git a/AnnService/src/IndexSearcher/main.cpp b/AnnService/src/IndexSearcher/main.cpp index 2c61f520b..0db44e906 100644 --- a/AnnService/src/IndexSearcher/main.cpp +++ b/AnnService/src/IndexSearcher/main.cpp @@ -1,6 +1,7 @@ // Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. +#include "inc/Core/Common.h" #include "inc/Helper/VectorSetReader.h" #include "inc/Helper/SimpleIniReader.h" #include "inc/Helper/CommonHelper.h" @@ -40,6 +41,8 @@ class SearcherOptions : public Helper::ReaderOptions AddOptionalOption(m_debugQuery, "-q", "--debugquery", "Debug query number."); AddOptionalOption(m_enableADC, "-adc", "--adc", "Enable ADC Distance computation"); AddOptionalOption(m_outputformat, "-of", "--ouputformat", "0: TXT 1: BINARY."); + AddOptionalOption(m_truthType, "-rt", "--truthtype", "truth file type. (TXT, XVEC or DEFAULT)"); + AddOptionalOption(m_spreadSearch, "-ss", "--spreadsearch", "Spread search."); } ~SearcherOptions() {} @@ -58,6 +61,8 @@ class SearcherOptions : public Helper::ReaderOptions VectorFileType m_dataFileType = VectorFileType::DEFAULT; + TruthFileType m_truthType = TruthFileType::DEFAULT; + int m_withMeta = 0; int m_K = 32; @@ -73,6 +78,8 @@ class SearcherOptions : public Helper::ReaderOptions bool m_enableADC = false; int m_outputformat = 0; + + bool m_spreadSearch = false; }; template @@ -165,7 +172,14 @@ int Process(std::shared_ptr options, VectorIndex& index) if (index.GetIndexAlgoType() == IndexAlgoType::SPANN) { int SPANNInternalResultNum; if (SPTAG::Helper::Convert::ConvertStringTo(index.GetParameter("SearchInternalResultNum", "BuildSSDIndex").c_str(), SPANNInternalResultNum)) + { + SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "SPANN Internal result number: %d\n", SPANNInternalResultNum); + SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Internal result number: %d\n", internalResultNum); internalResultNum = max(internalResultNum, SPANNInternalResultNum); + } + // internalResultNum = 1024; + // index.SetParameter("SearchInternalResultNum", std::to_string(internalResultNum).c_str(), "BuildSSDIndex"); + SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Final Internal result number: %d\n", internalResultNum); } std::vector results(options->m_batch, QueryResult(NULL, internalResultNum, options->m_withMeta != 0)); std::vector latencies(options->m_batch, 0); @@ -173,11 +187,13 @@ int Process(std::shared_ptr options, VectorIndex& index) SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "[query]\t\t[maxcheck]\t[avg] \t[99%] \t[95%] \t[recall] \t[qps] \t[mem]\n"); std::vector totalAvg(maxCheck.size(), 0.0), total99(maxCheck.size(), 0.0), total95(maxCheck.size(), 0.0), totalRecall(maxCheck.size(), 0.0), totalLatency(maxCheck.size(), 0.0); + for (int startQuery = 0; startQuery < queryVectors->Count(); startQuery += options->m_batch) { int numQuerys = min(options->m_batch, queryVectors->Count() - startQuery); + for (SizeType i = 0; i < numQuerys; i++) results[i].SetTarget(queryVectors->GetVector(startQuery + i)); - if (ftruth != nullptr) COMMON::TruthSet::LoadTruth(ftruth, truth, numQuerys, truthDim, options->m_truthK, (options->m_truthFile.find("bin") != std::string::npos)? TruthFileType::DEFAULT : TruthFileType::TXT); + if (ftruth != nullptr) COMMON::TruthSet::LoadTruth(ftruth, truth, numQuerys, truthDim, options->m_truthK, options->m_truthType); for (int mc = 0; mc < maxCheck.size(); mc++) @@ -190,7 +206,7 @@ int Process(std::shared_ptr options, VectorIndex& index) std::vector threads; threads.reserve(options->m_threadNum); auto batchstart = std::chrono::high_resolution_clock::now(); - + SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Spread Search Status: %d\n", options->m_spreadSearch); for (std::uint32_t i = 0; i < options->m_threadNum; i++) { threads.emplace_back([&, i] { NumaStrategy ns = (index.GetIndexAlgoType() == IndexAlgoType::SPANN)? NumaStrategy::SCATTER: NumaStrategy::LOCAL; // Only for SPANN, we need to avoid IO threads overlap with search threads. @@ -250,6 +266,7 @@ int Process(std::shared_ptr options, VectorIndex& index) GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc)); unsigned long long peakWSS = pmc.PeakWorkingSetSize / 1000000000; #endif + SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "[query]\t\t[maxcheck]\t[avg] \t[99%] \t[95%] \t[recall] \t[qps] \t[mem]\n"); SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "%d-%d\t%s\t%.4f\t%.4f\t%.4f\t%.4f\t\t%.4f\t\t%lluGB\n", startQuery, (startQuery + numQuerys), maxCheck[mc].c_str(), timeMean, l99, l95, recall, (numQuerys / batchLatency), peakWSS); totalAvg[mc] += timeMean * numQuerys; total95[mc] += l95 * numQuerys; @@ -349,6 +366,7 @@ int main(int argc, char** argv) exit(1); } + std::shared_ptr vecIndex; auto ret = SPTAG::VectorIndex::LoadIndex(options->m_indexFolder, vecIndex); if (SPTAG::ErrorCode::Success != ret || nullptr == vecIndex) @@ -385,6 +403,7 @@ int main(int argc, char** argv) for (const auto& iter : iniReader.GetParameters(sections[i])) { vecIndex->SetParameter(iter.first.c_str(), iter.second.c_str(), sections[i]); + SPTAGLIB_LOG(Helper::LogLevel::LL_Info, "Set [%s]%s = %s\n", sections[i].c_str(), iter.first.c_str(), iter.second.c_str()); } } diff --git a/CMakeLists.txt b/CMakeLists.txt index d6da2a832..b5a962b84 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -14,10 +14,14 @@ function(CXX_COMPILER_DUMPVERSION _OUTPUT_VERSION) set(${_OUTPUT_VERSION} ${COMPILER_VERSION} PARENT_SCOPE) endfunction() +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + if(NOT WIN32) CXX_COMPILER_DUMPVERSION(CXX_COMPILER_VERSION) endif() + + if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU") # require at least gcc 5.0 if (CXX_COMPILER_VERSION VERSION_LESS 5.0) diff --git a/buildtext2image10m.ini b/buildtext2image10m.ini new file mode 100644 index 000000000..29ea50fb2 --- /dev/null +++ b/buildtext2image10m.ini @@ -0,0 +1,63 @@ +[Base] +ValueType=Float +DistCalcMethod=InnerProduct +IndexAlgoType=BKT +Dim=200 +VectorPath=/home/v-zikaiwang/SPTAG/datasets/text2image1B/base.10M.fbin +VectorType=DEFAULT +QueryPath=/home/v-zikaiwang/SPTAG/datasets/text2image1B/query.heldout.30K.fbin +QueryType=DEFAULT +WarmupPath=/home/v-zikaiwang/SPTAG/datasets/text2image1B/query.heldout.30K.fbin +WarmupType=DEFAULT +TruthPath=/home/v-zikaiwang/SPTAG/datasets/text2image1B/gt100-heldout.30K.fbin +TruthType=DEFAULT +IndexDirectory=text2image10m + +[SelectHead] +isExecute=true +TreeNumber=1 +BKTKmeansK=32 +BKTLeafSize=8 +SamplesNumber=1000 +SaveBKT=false +SelectThreshold=50 +SplitFactor=6 +SplitThreshold=100 +Ratio=0.16 +NumberOfThreads=64 +BKTLambdaFactor=-1 + +[BuildHead] +isExecute=true +NeighborhoodSize=32 +TPTNumber=32 +TPTLeafSize=2000 +MaxCheck=8192 +MaxCheckForRefineGraph=8192 +RefineIterations=3 +NumberOfThreads=64 +BKTLambdaFactor=-1 + +[BuildSSDIndex] +isExecute=true +BuildSsdIndex=true +InternalResultNum=64 +ReplicaCount=8 +PostingPageLimit=12 +NumberOfThreads=64 +MaxCheck=8192 +TmpDir=/tmp/ + +[SearchSSDIndex] +isExecute=true +BuildSsdIndex=false +InternalResultNum=64 +NumberOfThreads=1 +HashTableExponent=4 +ResultNum=10 +MaxCheck=2048 +MaxDistRatio=8.0 +SearchPostingPageLimit=12 +SpreadSearch=true +doc2docRounds=2 +Doc2DocResults=32 \ No newline at end of file diff --git a/data.ipynb b/data.ipynb new file mode 100644 index 000000000..fba886c7d --- /dev/null +++ b/data.ipynb @@ -0,0 +1,245 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.05 0.05 0.15 0.25 0.35 0.45 0.55 0.65 0.75 0.85 0.95 1.05]\n", + "[ 2495. 386. 300. 391. 595. 1001. 1866. 4364. 7879. 17623.\n", + " 63100.]\n", + "[0.02495 0.02881 0.03181 0.03572 0.04167 0.05168 0.07034 0.11398 0.19277\n", + " 0.369 1. ]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "80 + 4 rounds Average Recall@10: 0.903927, qps: 117.375000\n", + "[-0.05 0.05 0.15 0.25 0.35 0.45 0.55 0.65 0.75 0.85 0.95 1.05]\n", + "[ 2623. 403. 358. 467. 716. 1256. 2272. 5021. 8930. 18759.\n", + " 59195.]\n", + "[0.02623 0.03026 0.03384 0.03851 0.04567 0.05823 0.08095 0.13116 0.22046\n", + " 0.40805 1. ]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAokAAAHSCAYAAACAdlGIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAACXmklEQVR4nOzdd1hUx/s28HuXLh0BQbCgYsGGXexYQMXeY0PEjpUkGhNjjzV2NOg3Rowldk3ssZtE7L0jilhoShOQuvP+wbvn57qgrFlcNPfnurwud87sOc+w5Tw7c2aOTAghQERERET0BrmuAyAiIiKioodJIhERERGpYZJIRERERGqYJBIRERGRGiaJRERERKSGSSIRERERqWGSSERERERqmCQSERERkRomiURERESkhkkiAJlMhunTp0uPQ0JCIJPJEBERobOYPrayZcti0KBBhX6ciIgIyGQyhISESGWDBg2CmZlZoR9b6e3Xuyi6cOECGjVqBFNTU8hkMly9elXXIX32WrRogRYtWug6DCL6BH0K55UPUehJojLhUv7T19eHk5MTBg0ahGfPnhX24QtddnY20tLSClT3p59+Qs+ePVG6dGnIZLJ3JmWJiYkYNmwY7OzsYGpqCk9PT1y+fLlAx2nRooX095bL5bCwsEClSpUwYMAAHDlypED7KIgDBw4U2Q9FUY7tfbKystCzZ0/Ex8djyZIl2LBhA8qUKZNv/YiICPj5+aF8+fIwNjaGg4MDmjVrhmnTpqnUe/N9IZPJYGNjg3r16uGXX36BQqFQ22+vXr0gk8kwadKkPI978uRJaV+XLl1S255X8q+MoWPHjnm2QyaT4ccff8y3rUoymQyjR49+b71PzZt/0/f905YzZ85g+vTpSExMVClPS0vDypUr4eXlBUdHR5ibm6NWrVr46aefkJOTk2fcO3bs0FpcuvbDDz+gU6dOKFGixDsTgEGDBkEmk8HCwgKvX79W2x4WFia9ZgV5b+fn6NGj8PT0hK2tLaysrFC/fn1s2LAhz7pr165FlSpVYGxsDFdXV6xYseKDj6stmzZtgkwm+6gdAvTv6X+sA82cORMuLi5IT0/H2bNnERISgr///hs3b96EsbHxxwpDK549e4bFixfj999/x8OHDyGEgLW1Ndq0aYORI0fm2xsxf/58vHr1CvXr10dUVFS++1coFPDx8cG1a9fw9ddfw9bWFqtWrUKLFi1w6dIluLq6vjdGZ2dnzJ07FwCQmpqKBw8eYNeuXdi4cSN69eqFjRs3wsDAQKp/7949yOWa/WY4cOAAVq5cqVEyVqZMGbx+/Vrl2IXhXbG9fv0a+vof7a2vsfDwcDx+/Bj/+9//MGTIkHfWffDgAerVqwcTExMMHjwYZcuWRVRUFC5fvoz58+djxowZKvXffF/ExcXh119/hb+/P+7fv4958+ZJ9ZKTk7F3716ULVsWv/32G+bNm/fOxGT69OnYu3dvgdu4b98+XLp0CXXq1Cnwc/4LqlSponbinzx5MszMzPDdd98VyjHPnDmDGTNmYNCgQbCyspLKHz58iDFjxqBVq1YIDAyEhYUFDh8+jFGjRuHs2bNYv359ocRTVEyZMgUODg6oVasWDh8+/M66+vr6SEtLw969e9GrVy+VbZs2bYKxsTHS09M/OJY//vgDXbp0gYeHB6ZPnw6ZTIZt27Zh4MCBePHiBSZMmCDVXb16NUaMGIHu3bsjMDAQf/31F8aOHYu0tLR8f/AVtpSUFEycOBGmpqY6OT79C6KQrVu3TgAQFy5cUCmfNGmSACC2bt1a2CG8FwAxbdo06bEy5kePHqnVXbdunTAxMREVKlQQU6ZMETt27BB79+4VK1euFO3atRNyuVz4+fmJzMxMtedGREQIhUIhhBDC1NRU+Pr65hnP1q1bBQCxfft2qSw2NlZYWVmJL7744r3tad68uahatapaeXZ2thg1apQAICZOnPje/bxPQECAKOhbKCsrS2RkZOS5zdfXV5iamv7reN6kSWxFzalTp9Re//yMGjVK6Ovri4iICLVtMTExKo/zel+kpqYKZ2dnYWpqqvKe/eWXX4SBgYE4fvy4ACBOnjyptv8TJ04IAMLd3V0AEJcuXVLZntfr2rx5c1G6dGlhbW0tOnbsqLLt0aNHAoBYuHDhe9sNQAQEBLy3niaaN28umjdvrtV9akPVqlULNa6FCxfm+X0XFxcnbt68qVbfz89PABBhYWFSmfK9UJD37KdC+feIi4tTO0e8Sfk+9/LyEl26dFHb7urqKrp3717g93Ze2rRpI0qWLCnS09OlsqysLFG+fHlRo0YNqSwtLU0UL15c+Pj4qDy/X79+wtTUVMTHx2t87ObNm+d7riqoSZMmiUqVKklxfKiUlJR/FUdhetd75N/SZbt1dk1i06ZNAeT2mrzp7t276NGjB2xsbGBsbIy6devijz/+UHt+YmIiJkyYgLJly8LIyAjOzs7SryoAyMzMxNSpU1GnTh1YWlrC1NQUTZs2xYkTJz445p9//hn+/v6YPn067t69i1mzZqF79+7o0KEDRo0ahQMHDuCff/7B8ePHMXDgQLXnlylTpkDDRDt27ECJEiXQrVs3qczOzg69evXC77//joyMjA+KX09PD8uXL4ebmxuCgoKQlJQkbXv7msSsrCzMmDEDrq6uMDY2RvHixdGkSRNpuHrQoEFYuXIlAKgNgb05bLh06VKUL18eRkZGuH37dp7XJCo9fPgQ3t7eMDU1RcmSJTFz5kwIIaTtyiGtkydPqjzv7X2+KzZl2ds9jFeuXEG7du1gYWEBMzMztGrVCmfPnlWpo7x04p9//kFgYKB0KUDXrl0RFxf3/hcAwPHjx9G0aVOYmprCysoKnTt3xp07d6TtgwYNQvPmzQEAPXv2hEwme+d1cuHh4XB2ds5zONre3v698RQrVgwNGzZEamqqShs2bdqENm3awNPTE1WqVMGmTZvy3ceYMWNgbW1d4B5lc3NzTJgwAXv37i3wJRTvo3xvbNu2DT/88AOcnZ1hbGyMVq1a4cGDB2r116xZg/Lly8PExAT169fHX3/9led+MzIyMG3aNFSoUAFGRkYoVaoUJk6cqPIZ9PX1hbGxscrrCADe3t6wtrbG8+fPtdLGNyUmJmL8+PEoVaoUjIyMUKFCBcyfP1+6bEAIAU9PT9jZ2SE2NlZ6XmZmJqpXr47y5csjNTUV06dPx9dffw0AcHFxkT4rERERsLW1RdWqVdWO3bVrVwBQa+/blD1e9+/fR//+/WFpaQk7Ozt8//33EELgyZMn6Ny5MywsLODg4IBFixapPF+T7/CXL19iwIABsLCwgJWVFXx9fXHt2rU8v2sKeo4pW7bsO9v3tr59++LgwYMqw/YXLlxAWFgY+vbtq9G+3pacnAxra2sYGRlJZfr6+rC1tYWJiYlUduLECbx8+RKjRo1SeX5AQABSU1Oxf//+fxXHhwgLC8OSJUuwePFijUZwlJerhIeHo3379jA3N0e/fv0A5I6Offnll9L7v1KlSvjxxx9VzhfvOte8fQ5QvlcfPHgg9ahbWlrCz89P7XKyjIwMTJgwAXZ2djA3N0enTp3w9OlTtWO8evUK48ePl3IUe3t7tGnT5r3fecpYbt++jb59+8La2hpNmjQBkPue7NChA/7++2/Ur18fxsbGKFeuHH799Ve1/Vy/fh3NmzeHiYkJnJ2dMXv2bKxbt07j+RY6SxKVQVpbW0tlt27dQsOGDXHnzh188803WLRoEUxNTdGlSxfs3r1bqpeSkoKmTZtixYoV8PLywrJlyzBixAjcvXtXerGSk5Px888/o0WLFpg/fz6mT5+OuLg4eHt7f9AkgAcPHmD06NFYu3YtJk6cCD09PSkW5RdzUlISatWqhdOnT+Po0aPYunXrB/1trly5gtq1a6sN/9avXx9paWm4f//+B+0XyE0Uv/jiC6SlpeHvv//Ot9706dMxY8YMeHp6IigoCN999x1Kly4tvcGHDx+ONm3aAAA2bNgg/XvTunXrsGLFCgwbNgyLFi2CjY1NvsfLyclB27ZtUaJECSxYsAB16tTBtGnT1K6rK4iCxPamW7duoWnTprh27RomTpyI77//Ho8ePUKLFi1w7tw5tfpjxozBtWvXMG3aNIwcORJ79+4t0PVxR48ehbe3N2JjYzF9+nQEBgbizJkzaNy4sfR5GD58OL799lsAwNixY7Fhw4Z3DjOWKVMGT548wfHjx997/Pw8fPgQenp60lDj8+fPceLECXzxxRcAgC+++AI7duxAZmZmns+3sLDQOOkbN26cRollQc2bNw+7d+/GV199hcmTJ+Ps2bPSiUVp7dq1GD58OBwcHLBgwQI0btwYnTp1wpMnT1TqKRQKdOrUCT/++CM6duyIFStWoEuXLliyZAl69+4t1Vu2bBns7Ozg6+srXau3evVq/Pnnn1ixYgVKliyp1TampaWhefPm2LhxIwYOHIjly5ejcePGmDx5MgIDAwHkngR/+eUXpKenY8SIEdJzp02bhlu3bmHdunUwNTVFt27dpNdZef3rhg0bYGdnl+/xo6OjAQC2trYFird3795QKBSYN28eGjRogNmzZ2Pp0qVo06YNnJycMH/+fFSoUAFfffUVTp8+LT2voN/hCoUCHTt2xG+//QZfX1/88MMPiIqKgq+vr1osBT3HfIhu3bpBJpNh165dUtnmzZtRuXJl1K5d+1/tu0WLFrh16xa+//57PHjwAOHh4Zg1axYuXryIiRMnSvWuXLkCAKhbt67K8+vUqQO5XC5t/5jGjx8PT09PtG/fXuPnZmdnw9vbG/b29vjxxx/RvXt3CCHQqVMnLFmyBG3btsXixYtRqVIlfP3119L7/0P16tULr169wty5c9GrVy+EhISoXbIzZMgQLF26FF5eXpg3bx4MDAzg4+Ojtq8RI0bgp59+Qvfu3bFq1Sp89dVXMDExee+PK6WePXsiLS0Nc+bMwdChQ6XyBw8eoEePHmjTpg0WLVoEa2trDBo0CLdu3ZLqPHv2DJ6enrh16xYmT56MCRMmYNOmTVi2bJnmf5TC7qpUDt0ePXpUxMXFiSdPnogdO3YIOzs7YWRkJJ48eSLVbdWqlahevbpKl7pCoRCNGjUSrq6uUtnUqVMFALFr1y614ymHc7Ozs9WGNxMSEkSJEiXE4MGDVcpRgOHmQYMGqQwl3L17V9SpU0cAEBYWFmLBggWiefPmYt26dUIIIZYtWyYaNWqU79/lXcPNpqamajEKIcT+/fsFAHHo0KF89ytE/sPNSrt37xYAxLJly6SyMmXKqMRTs2ZNtSGLt+U3pKscNrSwsBCxsbF5blP+nYTIHa4BIMaMGSOVKRQK4ePjIwwNDUVcXJwQ4v+GtE6cOPHefb5ruPnt17tLly7C0NBQhIeHS2XPnz8X5ubmolmzZlKZ8n3RunVr6X0mhBATJkwQenp6IjExMc/jKbm7uwt7e3vx8uVLqezatWtCLpeLgQMHSmWaDN3dvHlTmJiYSMO+48aNE3v27BGpqalqdZs3by4qV64s4uLiRFxcnLhz544YO3asAKAy9Pvjjz8KExMTkZycLIQQ4v79+wKA2L17t8r+3owzMTFRWFtbi06dOknb8xtuVr43Z8yYoTJM/W+Gm5WxVKlSReVzv2zZMgFA3LhxQwghRGZmprC3txfu7u4q9dasWSMAqAzrbtiwQcjlcvHXX3+pHDs4OFgAEP/8849UdvjwYQFAzJ49Wzx8+FCYmZnlOfT4Id4ebp41a5YwNTUV9+/fV6n3zTffCD09PREZGSmVrV69WgAQGzduFGfPnhV6enpi/PjxKs/Lb7g5LxkZGcLNzU24uLiIrKwsqTyv9+y0adMEADFs2DCpLDs7Wzg7OwuZTCbmzZsnlSckJAgTExOV76CCfofv3LlTABBLly6VynJyckTLli3VvhcKeo55U0GHm4UQokePHqJVq1ZSDA4ODmLGjBkavbfzkpKSInr16iVkMpkAIACIYsWKiT179qjUCwgIEHp6ennuw87OTvTp00fjY/+b4eZ9+/YJfX19cevWLSGEZpcWKc8L33zzjUr5nj17pM/am3r06CFkMpl48OCBECLv84LS26+n8r369nm3a9euonjx4tLjq1evCgBi1KhRKvX69u2rtk9LS8sPuiRGGUtel5aVKVNGABCnT5+WymJjY4WRkZH48ssvpbIxY8YImUwmrly5IpW9fPlS2NjYFPizrvTRehJbt24NOzs7lCpVCj169ICpqSn++OMPODs7AwDi4+Nx/PhxKZN/8eIFXrx4gZcvX8Lb2xthYWHSbOidO3eiZs2a0rDHm5TDinp6ejA0NASQ+0szPj4e2dnZqFu3rsZDXDk5OdizZw/Gjh0r7a9Pnz7IyMjAxo0bsXLlSoSEhODChQvSc7p06YJz58590MXKr1+/VhlWUFJO8MlrBp0mlLPLXr16lW8dKysr3Lp1C2FhYR98nO7du7+zR+Jtb/bGKWevZmZm4ujRox8cw/vk5OTgzz//RJcuXVCuXDmp3NHREX379sXff/+N5ORklecMGzZMZfi6adOmyMnJwePHj/M9TlRUFK5evYpBgwap9KjWqFEDbdq0wYEDBz4o/qpVq+Lq1avo378/IiIisGzZMnTp0gUlSpTA//73P7X6d+/ehZ2dHezs7FClShWsWLECPj4++OWXX6Q6mzZtgo+PD8zNzQEArq6uqFOnzjuHnC0tLTF+/Hj88ccfBe6tUPYmvv1L/d/w8/OTPvfA/13W8vDhQwDAxYsXERsbixEjRqjUGzRoECwtLVX2tX37dlSpUgWVK1eWvo9evHiBli1bAoDKsKeXlxeGDx+OmTNnolu3bjA2Nsbq1au11q6342ratCmsra1V4mrdujVycnJUeuOGDRsGb29vjBkzBgMGDED58uUxZ86cDz726NGjcfv2bQQFBRV46PDNyVd6enqoW7cuhBDw9/eXyq2srFCpUiXpdVLWLch3+KFDh2BgYKDS2yKXyxEQEKAShybnmA/Vt29fnDx5EtHR0Th+/Diio6P/9VAzABgZGaFixYro0aMHfvvtN2zcuBF169ZF//79VS6Lef36tcr7+k3GxsbvPXdkZWWpvKdevHiBrKwsZGRkqJXntSLCmzIzMzFhwgSMGDECbm5umjf6/xs5cqTK4wMHDkBPT086Hyt9+eWXEELg4MGDH3ysN3vdgdzvj5cvX0rnAOX39NvHHj9+vNq+rKyscO7cuQ++3OTtWJTc3Nyk7zUg91K0tz87hw4dgoeHB9zd3aUyGxsbtVGVgvhoUzxXrlyJihUrIikpCb/88gtOnz6tkgg9ePAAQgh8//33+P777/PcR2xsLJycnBAeHo7u3bu/95jr16/HokWLcPfuXWRlZUnlLi4uGsX+4MEDvHr1Cs2aNQOQe6K5du0aHj16JF0L1rhxY5QvX156TokSJZCTk4P4+HiNh5tMTEzyvO5QmXC+eQ3Kh0hJSQEAKQnIy8yZM9G5c2dUrFgR1apVQ9u2bTFgwADUqFGjwMfR5O8sl8tVkjQAqFixIgAU6nqVcXFxSEtLQ6VKldS2ValSBQqFAk+ePFG5Nqt06dIq9ZSXTCQkJOR7HGUCmd9xDh8+jNTU1A+a/VexYkVs2LABOTk5uH37Nvbt24cFCxZg2LBhcHFxQevWraW6ZcuWxf/+9z/IZDJpeYw3r128c+cOrly5goEDB6pcy9eiRQusXLkSycnJsLCwyDOOcePGYcmSJZg+fTp+//3398atTCynTZuGK1euqFx68qHe99ooX4e3VwgwMDBQe/+FhYXhzp07+f7QefNaPwD48ccf8fvvv+Pq1avYvHlzga4J/RBhYWG4fv16geNau3Ytypcvj7CwMJw5c+aDvz8WLlyI//3vf5g1a5ZGQ4dvvyaWlpYwNjZWG662tLTEy5cvVcoK8h3++PFjODo6olixYirPrVChgspjTc4xH0p57dzWrVtx9epV1KtXDxUqVPjX32GjR4/G2bNncfnyZekypF69eqFq1aoYN26cdFmMiYlJvpeFpKenv/e1/+eff+Dp6alWfubMGWzZskWl7NGjR++8bnPJkiV48eLFv/oRqK+vL3UkKT1+/BglS5ZUO39VqVJF2v6h3vX9YWFhgcePH0Mul6uc64G8v9cXLFgAX19flCpVCnXq1EH79u0xcOBAte+Z/OR3/nw7RmWcb55/Hj9+DA8PD7V6b38mCuKjJYn169eXrpPo0qULmjRpgr59++LevXswMzOTfpV89dVX8Pb2znMfmjRw48aNGDRoELp06YKvv/4a9vb20NPTw9y5c9Umy7zPy5cvpecDuUmLnZ2dymQBFxcXlS+9J0+eQC6XqywpUVCOjo55LpGjLPu31zjdvHkTwLv/ns2aNUN4eDh+//13/Pnnn/j555+xZMkSBAcHv3dZFqV/m8y+Lb9JP2+v2VbYlO+Dt4k3LprWBT09PVSvXh3Vq1eHh4cHPD09sWnTJpUk0dTUVOXx2zZu3AgAmDBhgsqyGko7d+6En59fns9VJn3Tp0/XqDdxyZIlmDFjBpYuXVqg57yLNl8bhUKB6tWrY/HixXluL1WqlMrjK1euSAnajRs3pGv9tE2hUKBNmzYq16K9SfnjSunkyZPSj84bN27kefJ4n5CQEEyaNAkjRozAlClTNHpuXq9JQV4nbX6HA9D6OSYvRkZG6NatG9avX4+HDx9q5ZrbzMxM6Vr4N69TNzAwQLt27RAUFITMzEwYGhrC0dEROTk5iI2NVfmRkpmZiZcvX7733FGzZk21tXS//PJLODg4SBOclBwcHPLdT1JSEmbPno1Ro0YhOTlZ6olLSUmBEAIREREoVqzYe39IGRkZabw0m9KHnC+0+f3Rq1cvNG3aFLt378aff/6JhQsXYv78+di1axfatWv33ufnd/782OcfnSwWp/ygKydFfPPNN1J2bWBg8M6TGACUL19eSnTys2PHDpQrVw67du1SebN8yEQICwsLlSFHBwcHvHz5EomJiVISmJiYiPj4eKnO//73PzRq1Ejt121BuLu746+//oJCoVD5gJw7dw7FihVTOwloIicnB5s3b0axYsWkGVP5sbGxgZ+fH/z8/JCSkoJmzZph+vTpUpKozQV9FQoFHj58qNI25QQd5a9V5a+6txf9zeuXY0Fjs7OzQ7FixXDv3j21bXfv3oVcLldLBj6E8gdFfsextbXV6hpiyh9k71qP821CCGzevBmenp5qsyMBYNasWdi0aVO+SSKQO+yydOlSzJgxo0A/kN5MLPOaaKBtytchLCxMGjYGcofZHj16hJo1a0pl5cuXx7Vr19CqVav3vp9SU1Ph5+cHNzc3NGrUCAsWLEDXrl1Rr149rbehfPnySElJee/3JJD7+o8ZMwZeXl4wNDSUEqQ3f+C+r22///47hgwZgm7dukmrBnwMBf0OL1OmDE6cOIG0tDSV79u3Z7Vrco75N/r27YtffvkFcrkcffr0+df7e/nyJbKzs/NMbrKysqBQKKRtyuHFixcvqvT2Xrx4EQqFQmX4MS/W1tZqfxtra2s4Ojpq9DdLSEhASkoKFixYgAULFqhtd3FxQefOnbFnz54C71OpTJkyOHr0KF69eqXSm3j37l1puzJuoGDnC02OrVAoEB4ertJ7mNf3OpDb4TNq1CiMGjUKsbGxqF27Nn744YcCJYn/RpkyZfJc1SGvsvfR2ezmFi1aoH79+li6dCnS09Nhb2+PFi1aYPXq1Xme2N5cnqN79+64du1anrPRlNm0Mtt+M7s+d+4cQkNDNY61XLlyyM7OlhLTevXqwcHBAQMHDsStW7dw+/ZtDBw4EAqFAk+fPsWUKVOwdOlSadFiTfXo0QMxMTEqs+RevHiB7du3o2PHjnler1gQOTk5GDt2LO7cuYOxY8fmO2wIQG3Yx8zMDBUqVFAZBlcmNW9/CD9UUFCQ9H8hBIKCgmBgYIBWrVoByH3j6+npqVxzBQCrVq1S21dBY9PT04OXlxd+//13lSGhmJgYbN68GU2aNHnn36mgHB0d4e7ujvXr16vEdPPmTfz5558fNPMPAP766y+VYTgl5bUzeQ2D5Oeff/6R7t7So0cPtX+9e/fGiRMn3nmNjTLpUw67FsT48eNhZWWFmTNnFjjWD1W3bl3Y2dkhODhYZVguJCRE7b3Sq1cvPHv2LM9rO1+/fo3U1FTp8aRJkxAZGYn169dj8eLFKFu2LHx9fT94uap36dWrF0JDQ/Nc4DkxMRHZ2dnS46FDh0KhUGDt2rVYs2YN9PX14e/vr/K9+K7PyunTp9GnTx80a9YMmzZt+uBenQ9R0O9wb29vZGVlqbxOCoVCLaHV5Bzzb3h6emLWrFkICgp6Z29bQdnb28PKygq7d+9Wec+mpKRg7969qFy5stTr1LJlS9jY2OCnn35S2cdPP/2EYsWK5TkLtzDY29tj9+7dav88PT1hbGyM3bt3Y/LkyR+07/bt2yMnJ0flfAHkDm/LZDIpAbOwsICtrW2BzhcFpdz38uXLVcrfHgXJyclRWWIOyP2blCxZslC+E97m7e2N0NBQle/g+Pj4d15Xnh+d3nbi66+/Rs+ePRESEoIRI0Zg5cqVaNKkCapXr46hQ4eiXLlyiImJQWhoKJ4+fYpr165Jz9uxYwd69uyJwYMHo06dOoiPj8cff/yB4OBg1KxZEx06dMCuXbvQtWtX+Pj44NGjRwgODoabm5t0TV5BFStWDJ6envj555+xdOlSmJiY4JdffkGvXr1QrVo1ALnLhDRu3Bjff/89qlSpggMHDqj11O3du1dqQ1ZWFq5fv47Zs2cDADp16iRd79ejRw80bNgQfn5+uH37tnTHlZycnAJf35GUlCQNHaalpUl3XAkPD0efPn0wa9asdz7fzc0NLVq0QJ06dWBjY4OLFy9ix44dKpNLlHfLGDt2LLy9vaGnp/fBv5yNjY1x6NAh+Pr6okGDBjh48CD279+Pb7/9Vrr2ytLSEj179sSKFSsgk8lQvnx57Nu3T+0aLE1jmz17No4cOYImTZpg1KhR0NfXx+rVq5GRkZHnr+APtXDhQrRr1w4eHh7w9/fH69evsWLFClhaWn7wsNT8+fNx6dIldOvWTXr/XL58Gb/++itsbGzyvKA6P5s2bYKenl6+J5JOnTrhu+++w5YtW9651IRyCPnatWsF6h21tLTEuHHjtDqBJT8GBgaYPXs2hg8fjpYtW6J379549OgR1q1bp3at0IABA7Bt2zaMGDECJ06cQOPGjZGTk4O7d+9i27ZtOHz4MOrWrYvjx49j1apVmDZtmrTUybp169CiRQt8//33Ku8hZa/4v7lG7euvv8Yff/yBDh06YNCgQahTpw5SU1Nx48YN7NixQ1rjcN26ddi/fz9CQkKk67pWrFiB/v3746effpJ6i5Wfle+++w59+vSBgYEBOnbsiBcvXqBTp06QyWTo0aMHtm/frhJHjRo1NLpGWVMF/Q7v0qUL6tevjy+//BIPHjxA5cqV8ccff0gjO2/2Qhb0HAPkLp/1+PFjaZ2806dPS9/XAwYMyPdWmXK5vMBD8gV5P+jp6eGrr77ClClT0LBhQwwcOBA5OTlYu3Ytnj59Kn3PA7lDlLNmzUJAQAB69uwJb29v/PXXX9i4cSN++OGHdy5Dpk3FihVDly5d1Mr37NmD8+fP57mtoDp27AhPT0989913iIiIQM2aNfHnn3/i999/x/jx41WuFxwyZAjmzZuHIUOGoG7dujh9+vS/WkLO3d0dX3zxBVatWoWkpCQ0atQIx44dU+uhe/XqFZydndGjRw/UrFkTZmZmOHr0KC5cuKC2HmhhmDhxIjZu3Ig2bdpgzJgxMDU1xc8//4zSpUsjPj5es1HAAs+D/kD53XFFiNwlAsqXLy/Kly8vsrOzhRBChIeHi4EDBwoHBwdhYGAgnJycRIcOHcSOHTtUnvvy5UsxevRo4eTkJAwNDYWzs7Pw9fUVL168EELkLmswZ84cUaZMGWFkZCRq1aol9u3bJ3x9fUWZMmVU9oUCLIFz4sQJYWhoKM6dOyeVJScni7/++ktaiuLatWsqy6i8TTmlP69/b0/Tj4+PF/7+/qJ48eKiWLFionnz5nn+DfPSvHlzlX2bmZkJV1dX0b9/f/Hnn3/m+Zy3l8CZPXu2qF+/vrCyshImJiaicuXK4ocfflC5K0d2drYYM2aMsLOzk5ZmEOLdS5nktwSOqampCA8PF15eXqJYsWKiRIkSYtq0aSInJ0fl+XFxcaJ79+6iWLFiwtraWgwfPlzcvHlTbZ/5xSZE3ivjX758WXh7ewszMzNRrFgx4enpKc6cOaNSJ7/3cn5L8+Tl6NGjonHjxsLExERYWFiIjh07itu3b+e5v4IsgfPPP/+IgIAAUa1aNWFpaSkMDAxE6dKlxaBBg9Tei+9aGikzM1MUL15cNG3a9J3Hc3FxEbVq1XpvnMplHN61BM6bEhIShKWl5b9eAuftWPJbBmPVqlXCxcVFGBkZibp164rTp0/neceVzMxMMX/+fFG1alVhZGQkrK2tRZ06dcSMGTNEUlKSSE5OFmXKlBG1a9dWWRJGiNylkeRyuQgNDZXKbG1tRcOGDd/bvjfldceVV69eicmTJ4sKFSoIQ0NDYWtrKxo1aiR+/PFHkZmZKZ48eSIsLS3V7mojRO6yHqampuLhw4dS2axZs4STk5OQy+XSd5/yb5rfvzc/Q+9aAke5hJVSfsugvP3e0OQ7PC4uTvTt21eYm5sLS0tLMWjQIPHPP/8IAGLLli0qdQt6jnn7e/TNf29+1guyrEt+34mavB82bdqk8p3coEEDtZiV1qxZIypVqiQMDQ1F+fLlxZIlS1SW7dKENu64oqTpEjj51X316pWYMGGCKFmypDAwMBCurq5i4cKFam1MS0sT/v7+wtLSUpibm4tevXqJ2NjYfJfAefu9mlcu8Pr1azF27FhRvHhxYWpqKjp27CiePHmiss+MjAzx9ddfi5o1awpzc3NhamoqatasKVatWvXeducXixC55+m8lqbL67vrypUromnTpsLIyEg4OzuLuXPniuXLlwsAIjo6+r1xKMmE0PHV9p+QgIAA7NixA7t370ajRo3yrPPXX3+hfPnyWl9Al4g+bbdv30bVqlWxb9++jzbs91+2Z88edO3aFX///TcaN26s63DU8P1AH9v48eOxevVqpKSk5DsB5m06uybxU7Rs2TJ07NgRTZs2Rf/+/bF37148ePAAjx49wr59+9CnTx94enr+65X7iejzc+LECXh4eDAhKARvr/+Xk5ODFStWwMLC4l/f7aSw8P1Ahentz8TLly+xYcMGNGnSpMAJIgCwJ/ED/P7775gzZw4uXLggXVQtk8nQtGlTTJ06VZpoQUREhW/IkCF4/fo1PDw8kJGRgV27duHMmTOYM2fOB0+QIPqUubu7o0WLFqhSpQpiYmKwdu1aPH/+HMeOHZPWfC4IJon/QlxcHB4+fAiFQoEKFSpodHcRIiLSjs2bN2PRokV48OAB0tPTUaFCBYwcObJA91Qn+hx9++232LFjB54+fQqZTIbatWtj2rRpGi//xCSRiIiIiNTwmkQiIiIiUsMkkYiIiIjU6HQx7c+JQqHA8+fPYW5urtXb1REREVHhEULg1atXKFmy5Ee9q9CngEmiljx//lwr9/glIiKij+/JkyfS3YkoF5NELVHeaPzJkydaudcvERERFb7k5GSUKlVKOo/T/2GSqCXKIWYLCwsmiURERJ8YXiqmjoPvRERERKSGSSIRERERqWGSSERERERqmCQSERERkRomiURERESkhkkiERERAQDKli2LSpUqwd3dHe7u7ti6dSsA4NChQ6hbty5q1KiBhg0b4tq1a3k+/8aNG2jWrBkqV66MatWqYfDgwXj9+rW0/dy5c6hZsyYqVqyIli1b4tmzZwCAhIQEeHp6onr16hg1apRUPy4uDi1atEBWVlYhtpryo/Mk8dmzZ+jfvz+KFy8OExMTVK9eHRcvXpS2CyEwdepUODo6wsTEBK1bt0ZYWJjKPuLj49GvXz9YWFjAysoK/v7+SElJUalz/fp1NG3aFMbGxihVqhQWLFigFsv27dtRuXJlGBsbo3r16jhw4EDhNJqIiKiI2rp1K65evYqrV6+id+/eSEhIQL9+/bB+/Xpcv34dCxcuRL9+/fJ8rrGxMYKCgnD37l1cu3YNqampmD9/PoDcO5P169cPS5cuxf3799G+fXuMHz8eALBp0yZ4enrixo0buHv3Lm7evAkACAwMxLx582BgYPBR2k6qdJokJiQkoHHjxjAwMMDBgwdx+/ZtLFq0CNbW1lKdBQsWYPny5QgODsa5c+dgamoKb29vpKenS3X69euHW7du4ciRI9i3bx9Onz6NYcOGSduTk5Ph5eWFMmXK4NKlS1i4cCGmT5+ONWvWSHXOnDmDL774Av7+/rhy5Qq6dOmCLl26SG9UIiKi/6Lw8HAUL14cVatWBQA0bdoUkZGRuHz5slpdV1dX1KhRAwCgp6eHevXqISIiAgBw6dIl6Ovrw9PTEwAwfPhw7N27F+np6TAwMEBaWhoUCgUyMjJgaGiIQ4cOwdraGg0bNvw4DSV1QocmTZokmjRpku92hUIhHBwcxMKFC6WyxMREYWRkJH777TchhBC3b98WAMSFCxekOgcPHhQymUw8e/ZMCCHEqlWrhLW1tcjIyFA5dqVKlaTHvXr1Ej4+PirHb9CggRg+fHiesaWnp4ukpCTp35MnTwQAER8fL7Kzs0V2drbIyckRQgiRk5Mjlb2rXKFQvLP8zTJluUKhKHC58m+aVyz5lRc0draJbWKb2Ca26dNvU5kyZUT16tVFtWrVhJ+fn4iKihIvX74UNjY24p9//hE5OTli9+7dAoDYvn37O9v06tUrUalSJbFjxw6RnZ0ttm3bJry8vFRitLOzE/fv3xcpKSmie/fuokaNGmLKlCkiKSlJNGnSRCQnJxf665SQkCAAiKSkJEGqdHrHlT/++APe3t7o2bMnTp06BScnJ4waNQpDhw4FADx69AjR0dFo3bq19BxLS0s0aNAAoaGh6NOnD0JDQ2FlZYW6detKdVq3bg25XI5z586ha9euCA0NRbNmzWBoaCjV8fb2xvz585GQkABra2uEhoYiMDBQJT5vb2/s2bMnz9jnzp2LGTNmqJWHh4fDzMxMitXR0RExMTFISkqS6tja2sLW1hbPnj1DamqqVO7g4AArKytEREQgMzNTKnd2doaZmRnCw8OhUCikchcXF+jr66sNv7u6uiI7OxuPHj2SyuRyOSpWrIjU1FQ8ffpUKjc0NES5cuWQlJSE6OhoqdzU1BSlSpVCfHw8Xrx4IZWzTWwT28Q2sU2fb5v27NkDd3d3PHz4EHPmzEGvXr2wZs0ahISEYPLkyXj58iVq1qyJ8uXLIzY2FqmpqXm2ycnJCX369EG9evVQtWpVhIWFISoqCkIIZGZmSm3KyclBZGQkXF1dERISIrVpzJgx8PX1xYMHDzBjxgykp6djxIgRqFy5stZfp8ePH4PyJhNCCF0d3NjYGEDuNQc9e/bEhQsXMG7cOAQHB8PX1xdnzpxB48aN8fz5czg6OkrP69WrF2QyGbZu3Yo5c+Zg/fr1uHfvnsq+7e3tMWPGDIwcORJeXl5wcXHB6tWrpe23b99G1apVcfv2bVSpUgWGhoZYv349vvjiC6nOqlWrMGPGDMTExKjFnpGRgYyMDOmx8t6P8fHx0m35ZDIZ5HI5FAoF3vwz51cul8shk8nyLc/JyVGJQS7PvVrgzQ/mu8r19PQghFApV8aSX3lBY2eb2Ca2iW1imz6vNj1//hxVqlRBYmKiSpvS09Ph5OSEs2fPomLFimptysrKwhdffIHixYsjODhYut3dhQsXMGjQINy5cwcKhQKvXr1CiRIlEB8fD1NTUyn28+fPY8WKFdi4cSOaN2+OX3/9FTk5ORg8eDBOnDih9dcpMTER1tbWSEpK4m1136LTnkSFQoG6detizpw5AIBatWrh5s2bUpJYlBkZGcHIyEitXE9PD3p6eiplyg/62zQtf3u/H1Iuk8k0KtdW7GwT28Q2sU0fUs42fbw2paamIisrC1ZWVpDL5di2bRtq1aoFPT09REVFwdHREXK5HHPmzEHLli1RqVIltRizs7PRr18/2NjY4H//+5/K/ZDr16+PrKwsnDx5Ep6envj555/RsWNHmJqaSrErFAp8++232LJlC+RyOVJTUyGXy6X/v9m2wn6dSMdJoqOjI9zc3FTKqlSpgp07dwLI7QoGgJiYGJWexJiYGLi7u0t1YmNjVfaRnZ2N+Ph46fkODg5qvYHKx++ro9xORET0OYuJiUH37t2Rk5MDIQTKlSuHX3/9FQAwdepU/PXXX8jOzoaHhwfWrl0rPW/q1KkoWbIkRowYga1bt2LXrl2oUaMGatWqBQBo3LgxVq5cCblcjo0bN2L48OFIT09HyZIlsWHDBpUYFi5ciIEDB6JEiRIAgJkzZ6J9+/bSNvq4dDrc3LdvXzx58gR//fWXVDZhwgScO3cOZ86cgRACJUuWxFdffYUvv/wSQO6wrr29PUJCQtCnTx/cuXMHbm5uuHjxIurUqQMA+PPPP9G2bVs8ffoUJUuWxE8//YTvvvsOMTEx0jT6b7/9Frt27cLdu3cBAL1790ZaWhr27t0rxdKoUSPUqFEDwcHB721LcnIyLC0t2V1NRESfpKSkJKSlpek6jHcqVqwYLC0ttbpPnr/zp9OexAkTJqBRo0bSxbHnz5/HmjVrpKVpZDIZxo8fj9mzZ8PV1RUuLi74/vvvUbJkSXTp0gVAbs9j27ZtMXToUAQHByMrKwujR49Gnz59ULJkSQC5yeiMGTPg7++PSZMm4ebNm1i2bBmWLFkixTJu3Dg0b94cixYtgo+PD7Zs2YKLFy+qLJNDRET0OUpKSkJQ0EpkZxftRav19Q0wenSA1hNFyptOk8R69eph9+7dmDx5MmbOnAkXFxcsXbpUZZHOiRMnIjU1FcOGDUNiYiKaNGmCQ4cOSZNegNxFOEePHo1WrVpBLpeje/fuWL58ubTd0tISf/75JwICAlCnTh3Y2tpi6tSpKmspNmrUCJs3b8aUKVPw7bffwtXVFXv27EG1atU+zh+DiIhIR9LS0pCdnQX92q0hM7PRdTh5EinxyL58FGlpaUwSPxKdDjd/TthdTUREn6qoqCisWbMGBs16QW5lp+tw8qRIjEPW6W0YNmyYyjyFf4vn7/xxSg8RERERqWGSSERERERqmCQSERERkRomiURERESkhkkiEREREalhkkhEREREapgkEhEREZEaJolEREREpIZJIhERERGpYZJIRERERGqYJBIRERGRGiaJRERERKSGSSIRERERqWGSSERERERqmCQSERERkRomiURERESkhkkiEREREalhkkhEREREapgkEhEREZEaJolEREREpIZJIhERERGpYZJIRERERGqYJBIRERGRGiaJRERERKSGSSIRERERqWGSSERERERqmCQSERERkRomiURERESkhkkiEREREalhkkhEREREapgkEhEREZEaJolEREREpIZJIhERERGpYZJIRERERGqYJBIRERGRGiaJRERERKSGSSIRERERqWGSSERERERqmCQSERERkRomiURERESkhkkiEREREalhkkhEREREapgkEhEREZEaJolEREREpIZJIhERERGpYZJIRERERGqYJBIRERGRGiaJRERERKRGp0ni9OnTIZPJVP5VrlxZ2p6eno6AgAAUL14cZmZm6N69O2JiYlT2ERkZCR8fHxQrVgz29vb4+uuvkZ2drVLn5MmTqF27NoyMjFChQgWEhISoxbJy5UqULVsWxsbGaNCgAc6fP18obSYiIiL6FOi8J7Fq1aqIioqS/v3999/StgkTJmDv3r3Yvn07Tp06hefPn6Nbt27S9pycHPj4+CAzMxNnzpzB+vXrERISgqlTp0p1Hj16BB8fH3h6euLq1asYP348hgwZgsOHD0t1tm7disDAQEybNg2XL19GzZo14e3tjdjY2I/zRyAiIiIqYnSeJOrr68PBwUH6Z2trCwBISkrC2rVrsXjxYrRs2RJ16tTBunXrcObMGZw9exYA8Oeff+L27dvYuHEj3N3d0a5dO8yaNQsrV65EZmYmACA4OBguLi5YtGgRqlSpgtGjR6NHjx5YsmSJFMPixYsxdOhQ+Pn5wc3NDcHBwShWrBh++eWXj/8HISIiIioC9HUdQFhYGEqWLAljY2N4eHhg7ty5KF26NC5duoSsrCy0bt1aqlu5cmWULl0aoaGhaNiwIUJDQ1G9enWUKFFCquPt7Y2RI0fi1q1bqFWrFkJDQ1X2oawzfvx4AEBmZiYuXbqEyZMnS9vlcjlat26N0NDQfOPOyMhARkaG9Dg5ORlAbu9mTk4OAEAmk0Eul0OhUEAIIdXNr1wul0Mmk+Vbrtzvm+UAoFAoClSup6cHIYRKuTKW/MoLGjvbxDaxTWwT2/TptuntmIoyZfu0+TpR3nSaJDZo0AAhISGoVKkSoqKiMGPGDDRt2hQ3b95EdHQ0DA0NYWVlpfKcEiVKIDo6GgAQHR2tkiAqtyu3vatOcnIyXr9+jYSEBOTk5ORZ5+7du/nGPnfuXMyYMUOtPDw8HGZmZgAAS0tLODo6IiYmBklJSVIdW1tb2Nra4tmzZ0hNTZXKHRwcYGVlhYiICKknFACcnZ1hZmaG8PBwlTezi4sL9PX1ERYWphKDq6srsrOz8ejRI6lMLpejYsWKSE1NxdOnT6VyQ0NDlCtXDklJSdLfDABMTU1RqlQpxMfH48WLF1I528Q2sU1sE9v0+bUpPj4en4rY2Fg4OTlp7XV6/PjxR43/UyITb6bVOpaYmIgyZcpg8eLFMDExgZ+fn0pvHQDUr18fnp6emD9/PoYNG4bHjx+rXF+YlpYGU1NTHDhwAO3atUPFihXh5+en0lN44MAB+Pj4IC0tDQkJCXBycsKZM2fg4eEh1Zk4cSJOnTqFc+fO5RlrXj2Jyg+ihYUFgP/Gr0+2iW1im9gmtunTb1NUVBTWrl0Lg2a9ILeyQ1GkSIxD1ultGDJkCJycnLT2OiUmJsLa2hpJSUnS+Zty6Xy4+U1WVlaoWLEiHjx4gDZt2iAzMxOJiYkqvYkxMTFwcHAAkPsr4O1ZyMrZz2/WeXtGdExMDCwsLGBiYgI9PT3o6enlWUe5j7wYGRnByMhIrVy5vzcpP+hv07T87f1+SLlMJtOoXFuxs01sE9vENn1IOdv0cdqU37GLImXMhf06URGYuPKmlJQUhIeHw9HREXXq1IGBgQGOHTsmbb937x4iIyOlHj8PDw/cuHFDZRbykSNHYGFhATc3N6nOm/tQ1lHuw9DQEHXq1FGpo1AocOzYMZWeRSIiIqL/Ep0miV999RVOnTqFiIgInDlzBl27doWenh6++OILWFpawt/fH4GBgThx4gQuXboEPz8/eHh4oGHDhgAALy8vuLm5YcCAAbh27RoOHz6MKVOmICAgQOrlGzFiBB4+fIiJEyfi7t27WLVqFbZt24YJEyZIcQQGBuJ///sf1q9fjzt37mDkyJFITU2Fn5+fTv4uRERERLqm0+Hmp0+f4osvvsDLly9hZ2eHJk2a4OzZs7Czy70eYsmSJZDL5ejevTsyMjLg7e2NVatWSc/X09PDvn37MHLkSHh4eMDU1BS+vr6YOXOmVMfFxQX79+/HhAkTsGzZMjg7O+Pnn3+Gt7e3VKd3796Ii4vD1KlTER0dDXd3dxw6dEhtMgsRERHRf0WRmrjyKUtOToalpSUvfCUiok9OVFQU1qxZ80lMXBk2bBgcHR21tl+ev/NXpK5JJCIiIqKigUkiEREREalhkkhEREREapgkEhEREZEaJolEREREpIZJIhERERGpYZJIRERERGqYJBIRERGRGiaJRERERKSGSSIRERERqWGSSERERERqmCQSERERkRomiURERESkhkkiEREREalhkkhEREREapgkEhEREZEaJolEREREpIZJIhERERGpYZJIRERERGqYJBIRERGRGiaJRERERKSGSSIRERERqWGSSERERERqmCQSERERkRomiURERESkhkkiEREREalhkkhEREREapgkEhEREZEaJolEREREpIZJIhERERGpYZJIRERERGqYJBIRERGRGiaJRERERKSGSSIRERERqdE4Sbx8+TJu3LghPf7999/RpUsXfPvtt8jMzNRqcERERESkGxonicOHD8f9+/cBAA8fPkSfPn1QrFgxbN++HRMnTtR6gERERET08WmcJN6/fx/u7u4AgO3bt6NZs2bYvHkzQkJCsHPnTm3HR0REREQ6oHGSKISAQqEAABw9ehTt27cHAJQqVQovXrzQbnREREREpBMaJ4l169bF7NmzsWHDBpw6dQo+Pj4AgEePHqFEiRJaD5CIiIiIPj6Nk8SlS5fi8uXLGD16NL777jtUqFABALBjxw40atRI6wESERER0cenr+kTatSooTK7WWnhwoXQ09PTSlBEREREpFsftE5iYmIifv75Z0yePBnx8fEAgNu3byM2NlarwRERERGRbmjck3j9+nW0atUKVlZWiIiIwNChQ2FjY4Ndu3YhMjISv/76a2HESUREREQfkcY9iYGBgfDz80NYWBiMjY2l8vbt2+P06dNaDY6IiIiIdEPjJPHChQsYPny4WrmTkxOio6O1EhQRERER6ZbGSaKRkRGSk5PVyu/fvw87OzutBEVEREREuqVxktipUyfMnDkTWVlZAACZTIbIyEhMmjQJ3bt313qARERERPTxaZwkLlq0CCkpKbC3t8fr16/RvHlzVKhQAebm5vjhhx8KI0YiIiIi+sg0nt1saWmJI0eO4O+//8b169eRkpKC2rVro3Xr1oURHxERERHpwAetkwgATZo0wahRozBx4kStJIjz5s2DTCbD+PHjpbL09HQEBASgePHiMDMzQ/fu3RETE6PyvMjISPj4+KBYsWKwt7fH119/jezsbJU6J0+eRO3atWFkZIQKFSogJCRE7fgrV65E2bJlYWxsjAYNGuD8+fP/uk1EREREn6oC9SQuX74cw4YNg7GxMZYvX/7OumPHjtU4iAsXLmD16tWoUaOGSvmECROwf/9+bN++HZaWlhg9ejS6deuGf/75BwCQk5MDHx8fODg44MyZM4iKisLAgQNhYGCAOXPmAMi9p7SPjw9GjBiBTZs24dixYxgyZAgcHR3h7e0NANi6dSsCAwMRHByMBg0aYOnSpfD29sa9e/dgb2+vcXuIiIiIPnUyIYR4XyUXFxdcvHgRxYsXh4uLS/47k8nw8OFDjQJQDlevWrUKs2fPhru7O5YuXYqkpCTY2dlh8+bN6NGjBwDg7t27qFKlCkJDQ9GwYUMcPHgQHTp0wPPnz1GiRAkAQHBwMCZNmoS4uDgYGhpi0qRJ2L9/P27evCkds0+fPkhMTMShQ4cAAA0aNEC9evUQFBQEAFAoFChVqhTGjBmDb775Js+4MzIykJGRIT1OTk5GqVKlEB8fDwsLC+nvIZfLoVAo8OafOb9yuVwOmUyWb3lOTo5KDHK5XIq3IOV6enoQQqiUK2PJr7ygsbNNbBPbxDaxTZ9um6KiorB27VoYNOsFuVXRXKlEkRiHrNPbMGTIEDg5OWntdUpMTIS1tTWSkpKk8zflKlBP4qNHj/L8vzYEBATAx8cHrVu3xuzZs6XyS5cuISsrS2Uou3LlyihdurSUJIaGhqJ69epSgggA3t7eGDlyJG7duoVatWohNDRUbTjc29tbGtbOzMzEpUuXMHnyZGm7XC5H69atERoamm/cc+fOxYwZM9TKw8PDYWZmBiD3+k1HR0fExMQgKSlJqmNrawtbW1s8e/YMqampUrmDg4N0J5vMzEyp3NnZGWZmZggPD1f58Lu4uEBfXx9hYWEqMbi6uiI7O1vltZLL5ahYsSJSU1Px9OlTqdzQ0BDlypVDUlKSyjqXpqamUtL74sULqZxtYpvYJraJbfr82qS8xe6nIDY2Fk5OTlp7nR4/fvxR4/+UFKgnUSkrKwuVK1fGvn37UKVKlX998C1btuCHH37AhQsXYGxsjBYtWkg9iZs3b4afn59Kbx0A1K9fH56enpg/fz6GDRuGx48f4/Dhw9L2tLQ0mJqa4sCBA2jXrh0qVqwIPz8/lSTwwIED8PHxQVpaGhISEuDk5IQzZ87Aw8NDqjNx4kScOnUK586dyzN29iSyTWwT28Q2sU2fS5vYk8iexLxoNLvZwMAA6enpWjnwkydPMG7cOBw5ckTl9n6fCiMjIxgZGamV6+npQU9PT6VM+UF/m6blb+/3Q8plMplG5dqKnW1im9gmtulDytmmj9Om/I5dFCljLuzXiT5gdnNAQADmz5+vNoNYU5cuXUJsbCxq164NfX196Ovr49SpU1i+fDn09fVRokQJZGZmIjExUeV5MTExcHBwAJDbVfz2bGfl4/fVsbCwgImJCWxtbaGnp5dnHeU+iIiIiP5rNF4n8cKFCzh27Bj+/PNPVK9eHaampirbd+3aVaD9tGrVCjdu3FAp8/PzQ+XKlTFp0iSUKlUKBgYGOHbsmHQnl3v37iEyMlIaFvbw8MAPP/yA2NhYaRbykSNHYGFhATc3N6nOgQMHVI5z5MgRaR+GhoaoU6cOjh07hi5dugDI7do/duwYRo8ercFfhoiIiOjzoXGSaGVlpZXb75mbm6NatWoqZaampihevLhU7u/vj8DAQNjY2MDCwgJjxoyBh4cHGjZsCADw8vKCm5sbBgwYgAULFiA6OhpTpkxBQECANBQ8YsQIBAUFYeLEiRg8eDCOHz+Obdu2Yf/+/dJxAwMD4evri7p166J+/fpYunQpUlNT4efn96/bSURERPQp0jhJXLduXWHEkaclS5ZALpeje/fuyMjIgLe3N1atWiVt19PTw759+zBy5Eh4eHjA1NQUvr6+mDlzplTHxcUF+/fvx4QJE7Bs2TI4Ozvj559/ltZIBIDevXsjLi4OU6dORXR0NNzd3XHo0CGVWdNERERE/yUazW5Wys7OxsmTJxEeHo6+ffvC3Nwcz58/h4WFhbT8y39NcnIyLC0tOTuKiIg+OVFRUVizZs0nMbt52LBhcHR01Np+ef7On8Y9iY8fP0bbtm0RGRmJjIwMtGnTBubm5pg/fz4yMjIQHBxcGHESERER0Uek8ezmcePGoW7dukhISICJiYlU3rVrVxw7dkyrwRERERGRbmjck/jXX3/hzJkzMDQ0VCkvW7Ysnj17prXAiIiIiEh3NO5JVCgUaqvFA8DTp09hbm6ulaCIiIiISLc0ThK9vLywdOlS6bFMJkNKSgqmTZuG9u3bazM2IiIiItIRjYebFy1aBG9vb7i5uSE9PR19+/ZFWFgYbG1t8dtvvxVGjERERET0kWmcJDo7O+PatWvYsmULrl+/jpSUFPj7+6Nfv34qE1mIiIiI6NOlcZIIAPr6+ujfv7+2YyEiIiKiIkLjJPHXX3995/aBAwd+cDBEREREVDRonCSOGzdO5XFWVhbS0tJgaGiIYsWKMUkkIiIi+gxoPLs5ISFB5V9KSgru3buHJk2acOIKERER0WdC4yQxL66urpg3b55aLyMRERERfZq0kiQCuZNZnj9/rq3dEREREZEOaXxN4h9//KHyWAiBqKgoBAUFoXHjxloLjIiIiIh0R+MksUuXLiqPZTIZ7Ozs0LJlSyxatEhbcRERERGRDmmcJCoUisKIg4iIiIiKkA++JvHFixdITk7WZixEREREVERolCQmJiYiICAAtra2KFGiBKytreHg4IDJkycjLS2tsGIkIiIioo+swMPN8fHx8PDwwLNnz9CvXz9UqVIFAHD79m2sWLECR44cwd9//43r16/j7NmzGDt2bKEFTURERESFq8BJ4syZM2FoaIjw8HCUKFFCbZuXlxcGDBiAP//8E8uXL9d6oERERET08RQ4SdyzZw9Wr16tliACgIODAxYsWID27dtj2rRp8PX11WqQRERERPRxFfiaxKioKFStWjXf7dWqVYNcLse0adO0EhgRERER6U6Bk0RbW1tERETku/3Ro0ewt7fXRkxEREREpGMFThK9vb3x3XffITMzU21bRkYGvv/+e7Rt21arwRERERGRbmg0caVu3bpwdXVFQEAAKleuDCEE7ty5g1WrViEjIwO//vprYcZKRERERB9JgZNEZ2dnhIaGYtSoUZg8eTKEEAByb8vXpk0bBAUFoXTp0oUWKBERERF9PBrdls/FxQUHDx5EQkICwsLCAAAVKlSAjY1NoQRHRERERLqh8b2bAcDa2hr169fXdixEREREVER88L2biYiIiOjzxSSRiIiIiNQwSSQiIiIiNQVKEmvXro2EhAQAuUvhpKWlFWpQRERERKRbBUoS79y5g9TUVADAjBkzkJKSUqhBEREREZFuFWh2s7u7O/z8/NCkSRMIIfDjjz/CzMwsz7pTp07VaoBERERE9PEVKEkMCQnBtGnTsG/fPshkMhw8eBD6+upPlclkTBKJiIiIPgMFShIrVaqELVu2AADkcjmOHTsGe3v7Qg2MiIiIiHRH48W0FQpFYcRBREREREXIB91xJTw8HEuXLsWdO3cAAG5ubhg3bhzKly+v1eCIiIiISDc0Xifx8OHDcHNzw/nz51GjRg3UqFED586dQ9WqVXHkyJHCiJGIiIiIPjKNexK/+eYbTJgwAfPmzVMrnzRpEtq0aaO14IiIiIhINzTuSbxz5w78/f3VygcPHozbt29rJSgiIiIi0i2Nk0Q7OztcvXpVrfzq1auc8UxERET0mdB4uHno0KEYNmwYHj58iEaNGgEA/vnnH8yfPx+BgYFaD5CIiIiIPj6Nk8Tvv/8e5ubmWLRoESZPngwAKFmyJKZPn46xY8dqPUAiIiIi+vg0ThJlMhkmTJiACRMm4NWrVwAAc3NzrQdGRERERLrzQeskKjE5JCIiIvo8aTxxhYiIiIg+f0wSiYiIiEiNTpPEn376CTVq1ICFhQUsLCzg4eGBgwcPStvT09MREBCA4sWLw8zMDN27d0dMTIzKPiIjI+Hj44NixYrB3t4eX3/9NbKzs1XqnDx5ErVr14aRkREqVKiAkJAQtVhWrlyJsmXLwtjYGA0aNMD58+cLpc1EREREnwKNk8SHDx9q7eDOzs6YN28eLl26hIsXL6Jly5bo3Lkzbt26BQCYMGEC9u7di+3bt+PUqVN4/vw5unXrJj0/JycHPj4+yMzMxJkzZ7B+/XqEhIRg6tSpUp1Hjx7Bx8cHnp6euHr1KsaPH48hQ4bg8OHDUp2tW7ciMDAQ06ZNw+XLl1GzZk14e3sjNjZWa20lIiIi+pTIhBBCkyfI5XI0b94c/v7+6NGjB4yNjbUakI2NDRYuXIgePXrAzs4OmzdvRo8ePQAAd+/eRZUqVRAaGoqGDRvi4MGD6NChA54/f44SJUoAAIKDgzFp0iTExcXB0NAQkyZNwv79+3Hz5k3pGH369EFiYiIOHToEAGjQoAHq1auHoKAgAIBCoUCpUqUwZswYfPPNNwWKOzk5GZaWlkhKSoKFhYU2/yRERESFKioqCmvWrIFBs16QW9npOpw8KRLjkHV6G4YNGwZHR0et7Zfn7/xpPLv58uXLWLduHQIDAzF69Gj07t0b/v7+qF+//r8KJCcnB9u3b0dqaio8PDxw6dIlZGVloXXr1lKdypUro3Tp0lKSGBoaiurVq0sJIgB4e3tj5MiRuHXrFmrVqoXQ0FCVfSjrjB8/HgCQmZmJS5cuSWs+ArmJcOvWrREaGppvvBkZGcjIyJAeJycnS+3IyckBkLtckFwuh0KhwJu5eH7lcrkcMpks33Llft8sB3KT2oKU6+npQQihUq6MJb/ygsbONrFNbBPbxDZ9um16O6aiTNk+bb5OlDeNk0R3d3csW7YMixYtwh9//IGQkBA0adIEFStWxODBgzFgwADY2RX8V8iNGzfg4eGB9PR0mJmZYffu3XBzc8PVq1dhaGgIKysrlfolSpRAdHQ0ACA6OlolQVRuV257V53k5GS8fv0aCQkJyMnJybPO3bt384177ty5mDFjhlp5eHg4zMzMAACWlpZwdHRETEwMkpKSpDq2trawtbXFs2fPkJqaKpU7ODjAysoKERERyMzMlMqdnZ1hZmaG8PBwlTezi4sL9PX1ERYWphKDq6srsrOz8ejRI6lMLpejYsWKSE1NxdOnT6VyQ0NDlCtXDklJSdLfDABMTU1RqlQpxMfH48WLF1I528Q2sU1sE9v0+bUpPj4en4rY2Fg4OTlp7XV6/PjxR43/U6LxcPPbMjIysGrVKkyePBmZmZkwNDREr169MH/+/AJ1B2dmZiIyMhJJSUnYsWMHfv75Z5w6dQpXr16Fn5+fSm8dANSvXx+enp6YP38+hg0bhsePH6tcX5iWlgZTU1McOHAA7dq1Q8WKFeHn56fSU3jgwAH4+PggLS0NCQkJcHJywpkzZ+Dh4SHVmThxIk6dOoVz587l2+63exKVH0Rld/V/4dcn28Q2sU1sE9v06bcpKioKa9eu/SSGm4cMGQInJyetvU6JiYmwtrbmcHMePngx7YsXL+KXX37Bli1bYGpqiq+++gr+/v54+vQpZsyYgc6dOxdohrChoSEqVKgAAKhTpw4uXLiAZcuWoXfv3sjMzERiYqJKb2JMTAwcHBwA5P4KePsYytnPb9Z5e0Z0TEwMLCwsYGJiAj09Pejp6eVZR7mPvBgZGcHIyEitXLm/Nyk/6G/TtPzt/X5IuUwm06hcW7GzTWwT28Q2fUg52/Rx2pTfsYsiZcyF/TrRB8xuXrx4MapXr45GjRrh+fPn+PXXX/H48WPMnj0bLi4uaNq0KUJCQnD58uUPCkihUCAjIwN16tSBgYEBjh07Jm27d+8eIiMjpR4/Dw8P3LhxQ2UW8pEjR2BhYQE3Nzepzpv7UNZR7sPQ0BB16tRRqaNQKHDs2DGVnkUiIiKi/xKNexJ/+uknDB48GIMGDcp3ONne3h5r1659774mT56Mdu3aoXTp0nj16hU2b96MkydP4vDhw7C0tIS/vz8CAwNhY2MDCwsLjBkzBh4eHmjYsCEAwMvLC25ubhgwYAAWLFiA6OhoTJkyBQEBAVIv34gRIxAUFISJEydi8ODBOH78OLZt24b9+/dLcQQGBsLX1xd169ZF/fr1sXTpUqSmpsLPz0/TPw8RERHRZ0HjJPHtC2vzYmhoCF9f3/fWi42NxcCBAxEVFQVLS0vUqFEDhw8fRps2bQAAS5YsgVwuR/fu3ZGRkQFvb2+sWrVKer6enh727duHkSNHwsPDA6ampvD19cXMmTOlOi4uLti/fz8mTJiAZcuWwdnZGT///DO8vb2lOr1790ZcXBymTp2K6OhouLu749ChQ2qTWYiIiIj+KzSeuLJu3TqYmZmhZ8+eKuXbt29HWlpagZLDzxHXWSIiok8V10nk+TsvGl+TOHfuXNja2qqV29vbY86cOVoJioiIiIh0S+MkMTIyEi4uLmrlZcqUQWRkpFaCIiIiIiLd0jhJtLe3x/Xr19XKr127huLFi2slKCIiIiLSLY2TxC+++AJjx47FiRMnpFvQHT9+HOPGjUOfPn0KI0YiIiIi+sg0nt08a9YsREREoFWrVtDXz326QqHAwIEDeU0iERER0WdC4yTR0NAQW7duxaxZs3Dt2jWYmJigevXqKFOmTGHER0REREQ68MG35atYsSIqVqyozViIiIiIqIjQOEnMyclBSEgIjh07htjYWLUbjx8/flxrwRERERGRbmicJI4bNw4hISHw8fFBtWrVIJPJCiMuIiIiItIhjZPELVu2YNu2bWjfvn1hxENERERERYDGS+AYGhqiQoUKhRELERERERURGieJX375JZYtWwYNb/lMRERERJ8QjYeb//77b5w4cQIHDx5E1apVYWBgoLJ9165dWguOiIiIiHRD4yTRysoKXbt2LYxYiIiIiKiI0DhJXLduXWHEQURERERFiMbXJAJAdnY2jh49itWrV+PVq1cAgOfPnyMlJUWrwRERERGRbmjck/j48WO0bdsWkZGRyMjIQJs2bWBubo758+cjIyMDwcHBhREnEREREX1EGvckjhs3DnXr1kVCQgJMTEyk8q5du+LYsWNaDY6IiIiIdEPjnsS//voLZ86cgaGhoUp52bJl8ezZM60FRkRERES6o3FPokKhQE5Ojlr506dPYW5urpWgiIiIiEi3NE4Svby8sHTpUumxTCZDSkoKpk2bxlv1EREREX0mNB5uXrRoEby9veHm5ob09HT07dsXYWFhsLW1xW+//VYYMRIRERHRR6Zxkujs7Ixr165hy5YtuH79OlJSUuDv749+/fqpTGQhIiIiok+XxkkiAOjr66N///7ajoWIiIiIigiNk8Rff/31ndsHDhz4wcEQERERUdGgcZI4btw4lcdZWVlIS0uDoaEhihUrxiSRiIiI6DOg8ezmhIQElX8pKSm4d+8emjRpwokrRERERJ+JD7p389tcXV0xb948tV5GIiIiIvo0aSVJBHInszx//lxbuyMiIiIiHdL4msQ//vhD5bEQAlFRUQgKCkLjxo21FhgRERER6Y7GSWKXLl1UHstkMtjZ2aFly5ZYtGiRtuIiIiIiIh3SOElUKBSFEQcRERERFSFauyaRiIiIiD4fGvckBgYGFrju4sWLNd09ERERERUBGieJV65cwZUrV5CVlYVKlSoBAO7fvw89PT3Url1bqieTybQXJRERERF9VBoniR07doS5uTnWr18Pa2trALkLbPv5+aFp06b48ssvtR4kEREREX1cGl+TuGjRIsydO1dKEAHA2toas2fP5uxmIiIios+ExklicnIy4uLi1Mrj4uLw6tUrrQRFRERERLqlcZLYtWtX+Pn5YdeuXXj69CmePn2KnTt3wt/fH926dSuMGImIiIjoI9P4msTg4GB89dVX6Nu3L7KysnJ3oq8Pf39/LFy4UOsBEhEREdHHp3GSWKxYMaxatQoLFy5EeHg4AKB8+fIwNTXVenBEREREpBsfvJh2VFQUoqKi4OrqClNTUwghtBkXEREREemQxkniy5cv0apVK1SsWBHt27dHVFQUAMDf35/L3xARERF9JjROEidMmAADAwNERkaiWLFiUnnv3r1x6NAhrQZHRERERLqh8TWJf/75Jw4fPgxnZ2eVcldXVzx+/FhrgRERERGR7mjck5iamqrSg6gUHx8PIyMjrQRFRERERLqlcZLYtGlT/Prrr9JjmUwGhUKBBQsWwNPTU6vBEREREZFuaDzcvGDBArRq1QoXL15EZmYmJk6ciFu3biE+Ph7//PNPYcRIRERERB+Zxj2J1apVw/3799GkSRN07twZqamp6NatG65cuYLy5csXRoxERERE9JFplCRmZWWhVatWiI2NxXfffYdt27bhwIEDmD17NhwdHTU++Ny5c1GvXj2Ym5vD3t4eXbp0wb1791TqpKenIyAgAMWLF4eZmRm6d++OmJgYlTqRkZHw8fFBsWLFYG9vj6+//hrZ2dkqdU6ePInatWvDyMgIFSpUQEhIiFo8K1euRNmyZWFsbIwGDRrg/PnzGreJiIiI6HOgUZJoYGCA69eva+3gp06dQkBAAM6ePYsjR44gKysLXl5eSE1NlepMmDABe/fuxfbt23Hq1Ck8f/5c5R7ROTk58PHxQWZmJs6cOYP169cjJCQEU6dOleo8evQIPj4+8PT0xNWrVzF+/HgMGTIEhw8flups3boVgYGBmDZtGi5fvoyaNWvC29sbsbGxWmsvERH9N40dOxZly5aFTCbD1atXpfIDBw6gdu3acHd3R7Vq1bB+/fo8n3/48GG4u7tL/0qWLInatWtL2xMSEtCvXz9UrFgRVatWxTfffCOVe3p6onr16hg1apRUPy4uDi1atJBur0uUF5nQ8FYpEyZMgJGREebNm6f1YOLi4mBvb49Tp06hWbNmSEpKgp2dHTZv3owePXoAAO7evYsqVaogNDQUDRs2xMGDB9GhQwc8f/4cJUqUAJB7f+lJkyYhLi4OhoaGmDRpEvbv34+bN29Kx+rTpw8SExOltR0bNGiAevXqISgoCACgUChQqlQpjBkzRvqwvSkjIwMZGRnS4+TkZJQqVQrx8fGwsLAAkDupRy6XQ6FQqNyRJr9yuVwuTQTKqzwnJ0clBrlcLsVakHI9PT0IIVTKlbHkV17Q2NkmtoltYpvYpvzbdPr0aVSoUAFNmzbFzp074e7uDiEE7O3tceLECdSoUQMPHz5E1apVER0dDXNz83e2qUOHDmjevDkCAwMBAN27d0eTJk3w5ZdfQqFQIDo6Gg4ODli1ahUSEhIwZcoUtGrVCkuXLkW1atXg6+uL0aNHo379+hBCICoqCmvXroVBs16QW9mhKFIkxiHr9DYMGTIETk5OWnudEhMTYW1tjaSkJOn8Tbk0nriSnZ2NX375BUePHkWdOnXU7tm8ePHiDw4mKSkJAGBjYwMAuHTpErKystC6dWupTuXKlVG6dGkpSQwNDUX16tWlBBEAvL29MXLkSNy6dQu1atVCaGioyj6UdcaPHw8AyMzMxKVLlzB58mRpu1wuR+vWrREaGppnrHPnzsWMGTPUysPDw2FmZgYAsLS0hKOjI2JiYqS2AYCtrS1sbW3x7NkzlV5TBwcHWFlZISIiApmZmVK5s7MzzMzMEB4ervJl4eLiAn19fYSFhanE4OrqiuzsbDx69EilPRUrVkRqaiqePn0qlRsaGqJcuXJISkpCdHS0VG5qaiolvS9evJDK2Sa2iW1im9gmzdvk6OgIa2trAMDTp0+l29kqFArExcVBoVDg5s2bsLS0RGRkJAwNDfNtk5mZGY4dO4bJkycjLCwMjx8/xrlz57Br1y6VNr169QopKSlIS0vDixcvkJSUhOfPn+P8+fMwMjJCw4YNERUVhaSkJMTHx+NTERsbCycnJ629TlzjOX8a9yS+a5kbmUyG48ePf1AgCoUCnTp1QmJiIv7++28AwObNm+Hn56fSYwcA9evXh6enJ+bPn49hw4bh8ePHKkPHaWlpMDU1xYEDB9CuXTtUrFgRfn5+KknggQMH4OPjg7S0NCQkJMDJyQlnzpyBh4eHVGfixIk4deoUzp07pxYvexLZJraJbWKb2CZN2+Ti4iL1JALA0aNH0a9fP5iamiIhIQHbt2+XOjXya9P8+fNx6dIlbNu2DQCwd+9ezJ8/HzVq1MDFixdhY2ODuXPnolatWkhLS4Ofnx/CwsLQqVMnfP3112jfvj32798PS0tLKUb2JLInMS8F7kl8+PAhXFxccOLEiUIJJCAgADdv3pQSxKLOyMgoz8XD9fT0oKenp1Km/KC/TdPyt/f7IeUymUyjcm3FzjaxTWwT2/Qh5Z9rm/T09JCdnY25c+di165daNasGS5cuIBOnTrhxo0bsLW1zbNNQgj88ssvWL58uVSuUChw/vx5zJkzB6tXr8bBgwfRuXNnREREwNzcHDt27JCeP2HCBHzzzTd4+PAh5syZAwCYMmUK7O3t84y1KFL+XQv7dSINJq64uroiLi5Oety7d2+1WcYfavTo0di3bx9OnDihcrs/BwcHZGZmIjExUaV+TEwMHBwcpDpvx6F8/L46FhYWMDExga2tLfT09PKso9wHERGRNl29ehXPnz9Hs2bNAAD16tWDs7Mzrly5ku9zTp06hfT0dHh7e0tlpUuXhpOTkzTS165dO2RmZqoNo54/fx6xsbHo0KEDxo4di4ULF2LBggUYO3ZsIbSOPgcFThLfHpU+cOCAytj+hxBCYPTo0di9ezeOHz8OFxcXle116tSBgYEBjh07JpXdu3cPkZGR0rCwh4cHbty4oTIL+ciRI7CwsICbm5tU5819KOso92FoaIg6deqo1FEoFDh27JjK8DMREZG2lCpVClFRUbhz5w4A4MGDBwgPD0elSpXyfc7atWsxaNAgld7FOnXqwMLCQlp95Pz58xBCoFSpUlKdrKwsTJo0SZo3kJqaKg3DpqSkFEbz6DOg8cQVbQoICMDmzZvx+++/w9zcXLrY1tLSEiYmJrC0tIS/vz8CAwNhY2MDCwsLjBkzBh4eHmjYsCEAwMvLC25ubhgwYAAWLFiA6OhoTJkyBQEBAdJw8IgRIxAUFISJEydi8ODBOH78OLZt24b9+/dLsQQGBsLX1xd169ZF/fr1sXTpUqSmpsLPz+/j/2GIiOizMnz4cOzfvx/R0dHw9vaGubk5Hjx4gDVr1qBXr17SNXNBQUEoXbo0AGDq1KkoWbIkRowYASB3cueuXbtw48YNlX3LZDKsX78eQ4cOxevXr2FkZISdO3eqXBK1cOFCDBw4UJrkOXPmTLRv317aRpSXAk9c0dPTQ3R0NOzsci9oNTc3x/Xr19V6/zQ6uEyWZ/m6deswaNAgALmLaX/55Zf47bffkJGRAW9vb6xatUplGPjx48cYOXIkTp48CVNTU/j6+mLevHnQ1/+/HPjkyZOYMGECbt++DWdnZ3z//ffSMZSCgoKwcOFCREdHw93dHcuXL0eDBg0K1Jbk5GRYWlrywlciIvrkREVFYc2aNZ/ExJVhw4Z90A088sPzd/4KnCTK5XK0a9dO+mWyd+9etGzZUm0JnF27dmk/yk8A32RERJSfpKQkpKWl6TqMfL148QK7du1iksjzt4oCDzf7+vqqPO7fv7/WgyEiIvrcJCUlIShoJbKzeXcT+rQUOElct25dYcZBRET0WUpLS0N2dhb0a7eGzMxG1+HkSREbgZy753UdBhUxOp24QkRE9F8hM7MpskO54lWCrkOgIogrSBIRERGRGiaJRERERKSGSSIRERERqWGSSERERERqmCQSERERkRomiURERESkhkkiEREREalhkkhEREREapgkEhEREZEaJolEREREpIZJIhERERGpYZJIRERERGqYJBIRERGRGiaJRERERKSGSSIRERERqWGSSERERERqmCQSERERkRomiURERESkhkkiEREREalhkkhEREREapgkEhEREZEaJolEREREpIZJIhERERGpYZJIRERERGqYJBIRERGRGiaJRERERKSGSSIRERERqWGSSERERERqmCQSERERkRomiURERESkhkkiEREREalhkkhEREREapgkEhEREZEaJolEREREpIZJIhERERGpYZJIRERERGqYJBIRERGRGiaJRERERKSGSSIRERERqWGSSERERERqmCQSERERkRomiURERESkhkkiEREREalhkkhEREREapgkEhEREZEanSaJp0+fRseOHVGyZEnIZDLs2bNHZbsQAlOnToWjoyNMTEzQunVrhIWFqdSJj49Hv379YGFhASsrK/j7+yMlJUWlzvXr19G0aVMYGxujVKlSWLBggVos27dvR+XKlWFsbIzq1avjwIEDWm8vERER0adCp0liamoqatasiZUrV+a5fcGCBVi+fDmCg4Nx7tw5mJqawtvbG+np6VKdfv364datWzhy5Aj27duH06dPY9iwYdL25ORkeHl5oUyZMrh06RIWLlyI6dOnY82aNVKdM2fO4IsvvoC/vz+uXLmCLl26oEuXLrh582bhNZ6IiArFgQMHULt2bbi7u6NatWpYv359nvUWLlyIatWqwc3NDV27dkViYiKA3HNTgwYNULNmTdSsWRNt27ZFREQEACAhIQGenp6oXr06Ro0aJe0rLi4OLVq0QFZWVmE3j+ijkQkhhK6DAACZTIbdu3ejS5cuAHJ7EUuWLIkvv/wSX331FQAgKSkJJUqUQEhICPr06YM7d+7Azc0NFy5cQN26dQEAhw4dQvv27fH06VOULFkSP/30E7777jtER0fD0NAQAPDNN99gz549uHv3LgCgd+/eSE1Nxb59+6R4GjZsCHd3dwQHBxco/uTkZFhaWiIpKQkWFhba+rMQEZEGhBAoXrw4Tp48iRo1aiAiIgKVK1dGXFwczM3NpXpHjhzBuHHjcO7cOZibm2P27NmIiorCypUroVAokJqaKtVfsmQJTp48id9//x1BQUGIj4/H1KlT0bJlSyxfvhzVqlXDgAEDEBAQgIYNG6rFFBUVhTVr1sCgWS/Irew+2t9CEzlP7iP7ypEiHaMiMQ5Zp7dh2LBhcHR01Np+ef7On76uA8jPo0ePEB0djdatW0tllpaWaNCgAUJDQ9GnTx+EhobCyspKShABoHXr1pDL5Th37hy6du2K0NBQNGvWTEoQAcDb2xvz589HQkICrK2tERoaisDAQJXje3t7qw1/vykjIwMZGRnS4+TkZABATk4OcnJyAOQmvnK5HAqFAm/m4vmVy+VyyGSyfMuV+32zHAAUCkWByvX09CCEUClXxpJfeUFjZ5vYJraJbSoKbcrJyYFMJsPLly+Rk5OD5ORkFC9eHPr6+irfzdeuXUPjxo1RrFgx5OTkwNvbG61atZJGtpTlQggkJSVJMerp6SElJQVZWVnIyMiAoaEhDhw4ACsrK9SrVw85OTlqbXq7DfTvKF97bb73KG9FNkmMjo4GAJQoUUKlvESJEtK26Oho2Nvbq2zX19eHjY2NSh0XFxe1fSi3WVtbIzo6+p3HycvcuXMxY8YMtfLw8HCYmZkByE1qHR0dERMTg6SkJKmOra0tbG1t8ezZM6SmpkrlDg4OsLKyQkREBDIzM6VyZ2dnmJmZITw8XOXN7OLiAn19fbXrNF1dXZGdnY1Hjx5JZXK5HBUrVkRqaiqePn0qlRsaGqJcuXJISkpSaa+pqSlKlSqF+Ph4vHjxQipnm9gmtoltKuptWrhwIbp164ZixYrh1atX2LRpEx4/fqzSpjp16iAoKAhnzpyBra0tVq1ahVevXiE+Ph4KhQIvXryAn58fwsLCYGtri2PHjiEmJgYNGjTAnj17UL16dXTs2BFOTk7o378/fvrpJymmt9sUHx8P0p7Y2Fg4OTlp7b335nuDVBXZ4eYzZ86gcePGeP78uUq3cq9evSCTybB161bMmTMH69evx71791T2ZW9vjxkzZmDkyJHw8vKCi4sLVq9eLW2/ffs2qlatitu3b6NKlSowNDTE+vXr8cUXX0h1Vq1ahRkzZiAmJibPePPqSVR+YSq7q3X9i/pz7CVgm9gmtoltelebMjMz4eXlhenTp6NZs2a4fPkyOnXqhKtXr8LW1lYllpUrV2LdunWQy+Xo0qULvvvuOyQlJcHMzEyKRaFQYO7cuYiOjkZQUJBam7788kt4enqiZMmSmDdvHgBgypQpcHd3l9oUFRWFtWvXFumh3E9puHnIkCFwcnLS2nsvMTER1tbWHG7OQ5HtSXRwcAAAxMTEqCSJMTExcHd3l+rExsaqPC87Oxvx8fHS8x0cHNQSPeXj99VRbs+LkZERjIyM1Mr19PSgp6enUqb88nqbpuVv7/dDymUymUbl2oqdbWKb2Ca26UPKNW3TjRs3EBUVBU9PTwBAvXr14OzsjOvXr6NNmzYqdQMCAhAQEAAAOHv2LJydndWSBD09PQwbNgyurq5YtWqVyrbz588jNjYWnTp1QtOmTbFhwwYIITBo0CCcOnVKalN+sdKHUf5dC/u9R0V4nUQXFxc4ODjg2LFjUllycjLOnTsHDw8PAICHhwcSExNx6dIlqc7x48ehUCjQoEEDqc7p06dVZpwdOXIElSpVgrW1tVTnzeMo6yiPQ0REn4ZSpUohKioKd+7cAQA8ePAA4eHhqFSpklrdqKgoAEBaWhqmTp2KiRMnAsi9FCkhIUGqt3XrVtSoUUPluVlZWZg0aRIWL14MIHdGtLLH6u1l2Ig+VTrtSUxJScGDBw+kx48ePcLVq1dhY2OD0qVLY/z48Zg9ezZcXV3h4uKC77//HiVLlpSGpKtUqYK2bdti6NChCA4ORlZWFkaPHo0+ffqgZMmSAIC+fftixowZ8Pf3x6RJk3Dz5k0sW7YMS5YskY47btw4NG/eHIsWLYKPjw+2bNmCixcvqiyTQ0RERV+JEiWwZs0a9OrVSxpiDAoKQunSpTF16lSULFkSI0aMAAB4eXlBoVAgMzMTAwYMwOjRowEAkZGRGD58uDRxpXz58ti4caPKcRYuXIiBAwdK17PPnDkT7du3l7YRfQ50ek3iyZMnpSGBN/n6+iIkJARCCEybNg1r1qxBYmIimjRpglWrVqFixYpS3fj4eIwePRp79+6FXC5H9+7dsXz5cmnyCJC7mHZAQAAuXLgAW1tbjBkzBpMmTVI55vbt2zFlyhRERETA1dUVCxYskD7wBcEp9EREupGUlIS0tDRdh5GvFy9eYNeuXUX6er9P6ZpELoHz8RSZiSufOr7JiIg+vqSkJAQFrUR2dtFfxLooJ2BMEnn+zkuRnbhCRET0PmlpacjOzoJ+7daQmdnoOpw8KWIjkHP3vK7DINIYk0QiIvrkycxsimwPmHiV8P5KREVQkZ3dTERERES6wySRiIiIiNQwSSQiIiIiNUwSiYiIiEgNk0QiIiIiUsMkkYiIiIjUMEkkIiIiIjVMEomIiIhIDZNEIiIiIlLDJJGIiIiI1DBJJCIiIiI1TBKJiKjAypYti0qVKsHd3R3u7u7YunVrnvXWrl0LV1dXlC9fHkOHDkVWVhYA4Pjx46hfvz7c3NxQtWpVTJw4EQqFAgDw6NEjNGjQAFWrVsWcOXOkfd25cwedOnUq/MYRkQomiUREpJGtW7fi6tWruHr1Knr37q22/dGjR/j+++/x119/4cGDB4iJicGaNWsAANbW1tiyZQtu376NS5cu4cyZM/j1118BACtXrkRAQACuX7+O9evX49WrVxBCYPz48Vi2bNlHbSMRMUkkIiIt27FjBzp16gQHBwfIZDKMGDECv/32GwCgVq1aKFeuHADA2NgY7u7uiIiIAAAYGBggLS0NWVlZUCgUkMvlCA4OhpeXF1xcXHTVHKL/LCaJRESkkYEDB6J69erw9/dHXFyc2vbIyEiUKVNGely2bFlERkaq1YuOjsaOHTvQoUMHAMDYsWOxe/dueHh44KuvvkJSUhJ27NiB8ePHF1pbiCh/+roOgIiIPh2nT59G6dKlkZWVhSlTpsDX1xcHDhzQeD/Jycno2LEjJk6ciLp16wIAHB0dcfjwYalOz549sWjRIpw4cQI//fQTjIyMMHfuXJUElIgKD5NEIiIqsNKlSwPIHRoeP348KlasmGed8PBw6XFERIT0PAB49eoV2rZti86dOyMwMDDP4+zcuRPly5eHu7s7qlSpgvPnz+PixYuYOnUq1q9fr+VWEVFeONxMREQFkpqaisTEROnxb7/9hlq1aqnV6969O/744w9ER0dDCIHg4GD06dMHAJCSkoK2bduibdu2mDJlSp7HSUxMxLJlyzBt2jQAQFpaGuRyOeRyOVJSUrTfMCLKE3sSiYioQGJiYtC9e3fk5ORACIFy5cpJM5OHDBmCTp06oVOnTihXrhxmzJiBxo0bAwBatGiB4cOHAwCWLVuG8+fPIzU1Fbt27QKQO6z83XffSceZNGkSpk+fDhMTEwDAlClTULduXRgaGmLt2rUfs8lE/2kyIYTQdRCfg+TkZFhaWiIpKQkWFha6DoeISCuSkpKQlpam6zDy9eLFC+zatQsGzXpBbmWn63DylPPkPrKvHGGM/5IiMQ5Zp7dh2LBhcHR01Np+ef7OH3sSiYgoT0lJSQgKWons7Cxdh0JEOsAkkYiI8pSWlobs7Czo124NmZmNrsPJkyI2Ajl3z+s6DKLPEpNEIiJ6J5mZTZEdghSvEnQdAtFni7ObiYiIiEgNk0QiIiIiUsMk8ROUnp6OLl26oGLFiqhZsybatGmDBw8e5Fk3MjISHTt2RKVKleDm5oYVK1YAAG7cuIFmzZqhcuXKqFatGgYPHozXr18DABISEuDp6Ynq1atj1KhR0r7i4uLQokULZGXxInYiIqLPHZPET9SwYcNw7949XLt2DZ07d8aQIUPU6ggh0LVrVwwcOBD37t3D7du30atXLwCAsbExgoKCcPfuXVy7dg2pqamYP38+AGDTpk3w9PTEjRs3cPfuXdy8eRMAEBgYiHnz5sHAwODjNZSIiIh0gkniJ8jY2Bjt27eHTCYDADRs2BARERFq9Y4dOwYjIyP07NlTKitRogQAwNXVFTVq1AAA6OnpoV69etI+DAwMkJaWBoVCgYyMDBgaGuLQoUOwtrZGw4YNC7dxRP9RBR0heNcowI0bN+Du7i79K1u2LGxscmclZ2VloUuXLqhZsya6deuG7Oxs6bjNmjVDQgIngBCRKiaJn4Fly5ahc+fOauW3b9+GnZ0d+vTpg1q1aqFr1654+PChWr3U1FT8/PPP0j769++PBw8eoFatWmjdujWcnJzwww8/4Icffij0thD9lxVkhOBdowDVq1fH1atXpX8dOnRAv379AACHDx+GjY0Nrl27BisrKxw6dAgAMGvWLIwePRrW1tYfr6FE9EngEjifuDlz5uDBgwc4duyY2rbs7GwcP34cZ8+eRdWqVREcHIxevXrh4sWLUp3MzEz07t0bXl5e6Nq1KwDA1NQUO3bskOpMmDABkyZNwoMHDzBnzhwAubfJqlmzZiG3jui/QzlCoNSwYUP8+OOPavVcXV2l/ytHAZSXhLwpPT0dmzZtwokTJwD83wgBkLv+oaGhIa5fv467d+/yByAR5Yk9iZ+wH3/8Ebt27cLBgwdRrFgxte2lS5dGrVq1ULVqVQDAgAEDcPnyZWniSVZWFnr37g1HR0csW7Ysz2OcP38esbGx6NChA8aOHYuFCxdiwYIFGDt2bOE1jIjyHSF409ujAG/atWsXypUrB3d3dwBAmzZtYG5ujpo1a8LS0hItW7ZEYGBgvp99IiL2JH6iFi9ejN9++w1Hjx6FlZVVnnXatWuHiRMn4tmzZ3BycsKBAwdQpUoVGBgYIDs7G3369IGNjQ3WrFkjXd/4pqysLEyaNAlbtmwBkHtCkslkkMlkSElJKczmEf2nvWuEQCmvUYA3rV27Fv7+/tJjuVyO//3vf9LjpUuXokuXLsjOzkbfvn2RkZGBgIAAtGzZUruNIaJPFpPET9DTp0/x5Zdfoly5cvD09AQAGBkZ4dy5c5g6dSpKliyJESNGwNTUFMHBwfDx8YEQApaWllLCt3XrVuzatQs1atRArVq1AACNGzfGypUrpeMsXLgQAwcOlCa7zJw5UxoOW7hw4cdsMtF/hnKE4OjRo3mOEADvHwV49OgRzp49i507d+b5/MePH+PAgQM4dOgQfH19MWzYMNSpUwcNGzbErVu3tNoeIvp0MUn8BDk7O0MIkee2mTNnqjz28vKCl5eXWr1+/fpJF7Tn59tvv1V53KFDB3To0EHDaImKhrFjx+KPP/7A48ePceXKFWkY9k3Hjx/HN998g5SUFMhkMvj4+GDevHmQy3OvzImMjERAQADu378PPT09jBw5EmPGjMGjR4/Qp08fpKSkoF+/ftJn586dO5g0aRL++OOPAsVYkBGCgowC/PLLL+jatWu++xg3bhyWLFkCuVwujRAo/09EpMQk8RORlJQkXXReVBUrVgyWlpa6DoMoTz169MDEiRPRpEmTfOtYW1tjy5YtKFeuHNLT09G6dWv8+uuvGDRokLTu6DfffCMtKxUTEwMAWLlyJQICAtCvXz+4ublhzJgxMDMzw/jx4xEcHFyg+Ao6QvC+UQCFQoGQkBD8+uuveR5n8+bNqFmzpnSt8jfffIOhQ4ciMzMT33//fYFiJaL/BiaJn4CkpCQEBa1EdnbRvtOJvr4BRo8OYKJIRVKzZs3eW0eZdAG5s43d3d2l9UPfte6ocuZwVlYWFAoF5HI5goOD4eXlBRcXlwLFV9ARgveNAsjlcjx58iTf7X379lV5XL9+fVy7dq1AMRLRfwuTxE9AWloasrOzoF+7NWRmNroOJ08iJR7Zl48iLS2NSSJ9FqKjo7Fjxw7s27cPgOq6o/fu3UPZsmWxaNEilCtXDmPHjsWgQYOwevVqfPXVV0hKSsKOHTvw559/vvMYRX2E4MWLF7oOgYh0iEniJ0RmZgO5lZ2uw8iTQtcBkE6FhYXB19cXL168gKWlJUJCQqThTKV169apTLJ4+vQpmjVrhl27duHGjRsICAhAbGws9PX1Ub9+faxcuRImJiZISEhAt27d8OLFCzRt2hSrVq0CkHsv8Z49e+LIkSNav1VkcnIyOnbsiIkTJ6Ju3boA3r3uqKOjIw4fPiw9v2fPnli0aBFOnDiBn376CUZGRpg7dy7KlCkj1flURgiI6L+LSSJREVeQBExJCIFWrVrh8uXLSExMBJB7p41JkyZJdWJjY+Hg4IDLly9rLQEbPnw4hg0bhkGDBmHHjh0YNGgQLly4oFLHz88Pfn5+0uNq1apJw6bKu4jUqFEDOTk56Nu3L+bPn4/p06dL9xKfOnUqWrZsiZs3b6JatWqFdi/xV69eoW3btujcuTMCAwOl8rzWHR01ahSysrJUYti5cyfKly8Pd3d3VKlSBefPn8fFixcxdepUrF+/Xqr3KYwQKGIjkHP3vK7DICId4WLaVGjCwsLQqFEjVKxYEfXq1Xvn0hpCCLRs2VJtNua+fftQuXJluLq6olu3bkhOTgaQu8RHgwYNULVqVekuMEDubNJOnTppNcbQ0FDpXrhVq1bF8OHDkZGRIW2/ceMGWrRogSpVqqBKlSrYtWsXAODixYtwd3eHm5ubSnJw/PhxDB8+vMAxKhOw+/fvY9KkSRg0aFC+dZcsWYLy5curlHl7e6vcqq127dpScqZMwG7cuIG7d+9Kd+7QJAGLjY3FxYsX0b9/fwBA9+7d8eTJkzzvO6x07tw5xMbGSq9VUbmXeEpKCtq2bYu2bdtiypQpKtvatWuHp0+f4tmzZwCgsu6oUmJiIpYtW4Zp06YByE0E5XI55HJ5vmuLKkcIiuI/mQkvHSH6L2OSSIXm3yY3KSkp8Pf3x549exAWFoaSJUti1qxZAP5vNun169exfv16vHr1CkIIjB8/XqM7SBQkxpo1a+LChQu4evUqbty4gdjYWKnHLS0tDZ07d8bs2bNx584d3Lx5E02bNgUAzJs3D8uXL8eFCxcwY8YMAMDr168xffp06V6776NJAnbr1i3s2bMH33zzTb77e/78OY4dO4YBAwYA0E4C9uTJEzg6OkJfP3dgQiaToXTp0oiMjMz3OWvXrsWAAQPyTEIL617iw4cPh7OzM54+fQpvb29UqFABADBkyBBpiZply5bh/Pnz2LVrl/TDQHmcN9cdrVmzJlasWCGtO6o0adIkTJ8+HSYmJgByb19Zt25djB07FpMnT9YoXiIiXeNwMxUKZXKjvHC/e/fuGD16NB48eCCdnJWUyc26deuwfft2qfzgwYOoVasWKleuDAAYNWoUvLy8sHDhQq3MJi1ojG8uaJyZmYnXr19La9Nt3rwZDRs2lJZV0dPTg51d7nWjyhjT09Ohp6cHAJg+fTrGjRuX7/p1b3tXAvZmjFlZWRg6dCjWrl0rHSsvISEhaN++Pezt7QHkJmC+vr6oVasWunTpAicnJ/j7++PAgQMFiu9DpKamYsuWLTh79qzatsK8l/jq1avzLP/555+l/3/33Xf47rvv8t1HfuuO5neMoUOHYujQoe+Mi4ioqGKSSIVCG8lNZGSkyoX+ZcuWRVRUFLKzsz94NumHxAgAERER6Ny5M8LDw+Hj44NRo0YByJ3xamRkhA4dOuDp06eoUaMGFi1aBDs7O0ydOhXDhw9HamoqFi5ciKtXr+Lhw4cF7kXUxIwZM9CtWzdUqVJFGqZ9mxACv/zyC5YvXy6VaSMBK1WqlPS66OvrQwiByMhIlC5dOs/627dvR9WqVeHm5qZSrum9xJs2bYoNGzZACIFBgwbh1KlTKnU5c5iI6N9hkkg6VZDkJi8fMpv03yhbtiyuXbuGlJQU9O/fH7t27UKfPn2QnZ2No0eP4uzZsyhZsiS+/fZbjBw5Ejt27ECVKlVw+vRpAEBOTg68vLywYcMG/Pbbb9ixYwcsLCywePFiWFtb53vcgiZgp06dQmRkJIKCgpCdnY3k5GSULVsWFy5ckHo2T506hfT0dHh7e+d5LE0SsDfZ29ujdu3a2LhxIwYNGoSdO3fC2dlZLdFWevuewkDB7iKiyb3EOXOYiOjfY5JIhUIbyU3p0qVx5MgRqW5ERIRKz59SQWeTfmiMbzIzM0OfPn2wadMm9OnTB6VLl4anpyecnJwA5A7f5pWELV26FD179oSVlRVmzZqF69evY8OGDVi6dKl0vWJeCpqA/fXXXyp/pzcXgVZau3YtBg0alOdwtCYJWF5Wr16NQYMGYc6cObCwsMC6desA5F7v16lTJ2mCyr1793D16lW14Wxt30ucM4eJiP49JolUKLSR3LRt2xYBAQG4e/cuKleujFWrVqFPnz4qz1fOJlX2KhZkNqmmMT548ABlypSBgYEBMjMzsXv3bmkmbq9evbB27VokJyfDwsICBw4cUBuaffToEY4cOYKDBw8iOTkZ2dnZ0r1ytZmAvUtSUpK0HmFeNEnAlPt7cyjXwsJCmtWtFBUVJU00ioqKkurdv38fKSkpKm1v2bIlnj9/rnYc5fMASMvnKMvq1KmDo0eP5llXOZRblNcWFa8SdB0CEdE7MUl8y8qVK7Fw4UJER0dLMxjr16+v67A+Sf82uTE3N8fPP/+MLl26IDs7G9WqVVPrGcxvNqmhoSHWrl2rlRiPHz+O5cuXQ09PD9nZ2WjVqpV0j9vSpUvj22+/RaNGjSCXy+Hk5IQ1a9aoHGPcuHFYunQpZDIZLC0t0bdvX1SvXh1mZmbYunWrWkwfmoApGRkZ4c6dO2rlyhnRb5cDmiVgKSkp2LptG3Kys9X2Q0REnw+ZyO9mof9BW7duxcCBAxEcHIwGDRpg6dKl2L59O+7duyfNBs1PcnIyLC0tkZSUBAsLC63GFRUVhTVr1sCgWa8i2yuiSIxD1ult6NatG2xtbXUdTr6UQ8tF1aeUgH0KQ7lF+TOT8+Q+sq8cYYz/EmPUjk8hRuV5ZtiwYXB0dNTafgvz/P2pK7pnSx1YvHgxhg4dKvWqBAcHY//+/fjll1/eufYcASI9FYBMrcer6JEBKPq/iz6FBIxDuUREnzcmif9fZmYmLl26pLLgrVwuR+vWrREaGqpWPyMjQ+WuG0lJSQCAhIQE5OTkAIB03ZlCocCbHbb5lcvlcshkMrVy5bVbIiW+yN4jWSTHARDQq1gXMhNzXYeTJ0VCNBSRdz6JGD8FRfr9+Dr388gY/x3GqB2MUTtESjyA3FtnmpqaFvjc+r5zrvIWphxYVcfh5v/v+fPncHJywpkzZ+Dh4SGVT5w4EadOncK5c+dU6k+fPv2ds1KJiIjo0/HkyRM4OzvrOowihT2JH2jy5MkIDAyUHisUCsTHx6N48eJ5rvFWlCQnJ6NUqVJ48uRJkb3+gjFqB2PUDsaoHYxROxijdgkh8OrVK5QsWVLXoRQ5TBL/P1tbW+jp6SEmJkalPCYmBg4ODmr1jYyMYGRkpFJW0FutFRUWFhZF/sPLGLWDMWoHY9QOxqgdjFF7LC0tdR1CkSTXdQBFhaGhIerUqYNjx45JZQqFAseOHVMZfiYiIiL6L2BP4hsCAwPh6+uLunXron79+li6dClSU1Ol2c5ERERE/xVMEt/Qu3dvxMXFYerUqYiOjoa7uzsOHTok3YXic2FkZIRp06apDZcXJYxROxijdjBG7WCM2sEY6WPh7GYiIiIiUsNrEomIiIhIDZNEIiIiIlLDJJGIiIiI1DBJJCIiIiI1TBKJiIiISA2TRCIiIiJSwySRJEV1NaSiGhdpV0ZGhvT/ovqaJyQk6DqE94qNjUV4eLiuw3inBw8e4Mcff9R1GO/09ntQoVDoKJKCK6qfG/p0MUn8j3r69CkOHz6M7du34/HjxwAAmUxWpL4IU1JSkJ2dDZlMVmS//GJiYnDp0iUcOXIEaWlpug4nT5GRkfjtt9+watUqXLp0Sdfh5On27dvo3r27dFvMoviaX7lyBba2trhy5YquQ8nX9evX0bRpUxw+fBhxcXG6DidP169fR4MGDRAUFIT4+Hhdh5OnsLAwTJw4EaNGjcKCBQsAAHJ50TpdPnnyBEeOHMFvv/2G+/fvAyh63+EAkJOTo+sQ6N8Q9J9z/fp1UaJECVGvXj2hp6cn6tatK8aMGSNtz8nJ0WF0uW7fvi28vb3F5s2bRWZmphBCCIVCoeOoVF2/fl1UqVJF1KxZU8hkMtG+fXtx48YNXYel4vr166JUqVLC09NTWFpaCk9PT3H16lVdh6VCoVAIX19fYWlpKTp06CCOHj2qsq0ouHr1qjA3NxeBgYG6DiVf9+/fF8WLFxfjxo0Tr169UtteFD7XV69eFSYmJsLX11dYWVmJFStW6DokNdevXxe2traiZ8+eomXLlqJWrVrip59+krYXhffktWvXRIkSJYS3t7ewsbERDRs2FIMHD5a2F4XXWojc7/GRI0cKLy8vMX36dHH48GFdh0QaKlo/jajQJSUlYcCAAfjiiy9w5MgRPH78GJ07d8aJEyfQoUMHALm/mHX5azQiIgLdunXD8ePHERQUhL179yIrK6tI9S6FhYXB29sb3bt3x+7du3Hnzh1cv34da9eu1XVoknv37sHLywsDBw7E/v37cePGDVy7dg13797VdWgqZDIZTE1NUblyZRgYGGDevHk4cuSItE3Xbt68CQ8PD4wfPx6LFi0CkDuke+PGDWRnZ+s4uv+zevVqeHl5YenSpTA1NcWWLVuwYsUKbNiwAYDuP9dXr16Fh4cHxo0bh5CQEPTt2xe//fYbnj9/rrOY3vbixQv0798fgwcPxrZt27Br1y44ODjg9evXUh1d99bFxMSgT58+GDx4MPbu3Yu7d+/C29sb69atQ8eOHQHo/rUGgLt378LDwwOvXr1C8eLF8ffff6Nv375YunSpTuMiDek6S6WP6/Hjx6JixYrizJkzUtmrV6/Etm3bRKVKlUTPnj11GJ0QWVlZYuHChaJTp07i8uXLok2bNqJOnTpi586dRaZHMS0tTQwfPlz4+/uLjIwMkZ2dLYQQIjg4WFStWlWkp6frPMbU1FQxZMgQMWzYMJGVlSXF06NHD/HDDz+ImTNnii1btug0xjdt3rxZzJs3T5w7d054e3sLLy8vceXKFTF//nzx+PFjncX16tUr0bx5c2FlZSWVdevWTdSqVUvIZDLh6ekpli1bprP43tSjRw8ploYNG4qmTZuK8uXLi/Lly4sGDRpIvUu6eG8+fPhQWFpaim+++UYq27lzp7CwsBDHjx8XQhSN3q9Lly6JypUriwcPHkhlfn5+olu3bqJv375i5MiRUrmu4j19+rRwd3cXz58/l8pu374tSpUqJWxsbESHDh10EtfbJkyYILp27So9fvz4sZg7d66QyWRi3rx5OoyMNMGexP8Yc3NzZGVl4cyZM1KZmZkZOnXqhG+//Rb37t3D6tWrdRafnp4eWrZsif79+6NWrVrYv38/bGxsMGfOHOzduxeZmZk671HMyclBZmYmmjRpAkNDQ+jp6QEAHBwcEB8fj8zMTJ3FpiSXy9GpUyeMGjUK+vr6kMlkmDVrFnbu3Ilbt/5fe3ce1NTV/gH8G7YICChCBRUREXFBQUUplaVaUBQGqVWLyxSH1hm3uuMCFDtTFWtVxA11bBGXkZHWCJa6FvdtFIgbCi6oaBVF1CBogOT5/cEveY3RvogxN/g+nxkHvDm5fHNySZ6ce+7hMvbu3YuFCxdi5syZQkcFUHdcZmVloU+fPoiJiYGlpSXCwsIwd+5ciMViAMJMyjc2Nsa4ceNgZ2eHL7/8EiEhIaiurkZsbCyOHTuGVq1aYdu2bdi6daves72utrYWUqkU69atg7W1NSQSCc6cOYNt27ZBJpMhIiICgDCjsyKRCCtXrkRiYqJ629ChQxEYGIgff/wRcrncIOb8WVpaoqqqClu3bkVtbS1++uknbNmyBW5ubvjkk0+Qk5MDf39/AMLNUZTL5Xjy5InGCKxcLoejoyMSEhJQVFSEHTt2CJJNhYhw69YtmJmZqbe1bdsW33//PZYtW4YffvgBqampAiZk9SZwkcr07OXLlxQVFUUhISF04cIFjdsqKyspPDycIiMjBUpXRzUyp1JVVaUeUdy5cyfV1NQQEVFmZqYQ8YiIND7Fq/KePn2aPDw8NEZqrly5ovdsKnK5XP39+fPnycLCQt1nCoWC5syZQ97e3vTw4UOhIqoVFhaSj4+P+v9BQUFkYWFBn376KR07dkzAZEQvXrygjIwMcnFxIV9fX7p//776tsePH1Pfvn1p9OjRguVTjWilpaVRUFAQBQcHU0JCgkab9PR06tKlC928eVOwfK9S/Y6kpqaSq6srnT179q1t9enZs2c0e/Zsat26NQUHB5OJiQn98ccf6ttzcnLIwcGBDh8+LFjG27dvU7t27SgqKorS09Pp6NGjZGNjQ3FxcURE1KdPH5ozZ45g+VSSkpKoU6dOVFBQoLG9vLycpk2bRr6+vnTv3j2B0rH6Ev6jG9MrsViMWbNmIT8/HwsWLNBYKsPCwgKBgYEoKioS9Epd1cgcUDdqZ25ujl27dqlHFCUSCSZMmIAJEybg/v37gmR0dHQEULcshiqvUqmETCZT911cXBymTp2KZ8+eCZLx1U/x3bt3x/Xr1xEeHg6lUgkjIyO4urqiqqpKo51QOnToALFYjJKSEnzzzTcoKCjA0qVL4eDggBkzZuDo0aOCZWvSpAlCQ0OxatUqJCQkwN7eHkDdsWlrawsvLy+UlJQINgdMNaL1+eefo6amBgcPHkRxcbFGG0dHRygUCkFGv970M1WjmSNHjgQRISUl5a1t9cna2hrx8fE4duwY4uPj0alTJwQEBGjc3rRpU1hZWQmSj4jQtm1b7NixA/n5+YiNjcWoUaMwfvx4LFiwAADg4uKCkpISQfK9ytvbG1ZWVti0aRPu3r2r3t68eXOEhobi0qVLgr1+s/ozEToA0y+lUgkPDw9kZmbiiy++gFKpxMSJE9GvXz8AdZON27RpAxMTwzg0jI2NUVtbCwsLC2RlZSEiIgJjxoyBqakpjh49qi7WhPLqm1p1dTUqKipgYmKC+fPnY8mSJTh16hRsbGwETPgfDg4OAP6T+eLFi/Dw8FCfzhUKEaG2thZEBF9fXxgZGSE7OxteXl5wdnbG5s2b0a5dO0EzmpubIzg4GEZGRuoPBaqvZWVl8PLyErTAURUPGzZsQGRkJLKzs5GYmIh58+ZBLpfj77//RosWLWBtbS1YxtcpFAqIxWLMnj0by5cvR25uLnr16iV0LFhZWcHKygpKpRJisRhXrlxRn2LOzMxE06ZN0bp1a0GyqS6a6d27Nw4cOAC5XI7Kykp06tQJQN2UA5lMBj8/P0HyvcrPzw8jR45EcnIyxGIxxo4di/bt2wMAunXrhrZt22qsjcoMlKDjmOyDUSgUWqdtVadyVNvPnTtHXl5e1LNnT/L09KQhQ4aQtbW13pZI+beMr1O1Gz9+PNna2tKlS5c+eD5VnvpmPHXqFPXu3ZtmzZpFYrGYzp07p4+I75SRqG5aQWxsLNnb2xtUP27dupV8fHy0+u358+cfPJ8qz7v0Y1VVFcXGxpKjoyNdvXr1Q8dT53lbRtXXwsJCGjZsGDk5OZGjoyMFBASQra0t5efnC57xTQoKCsjMzEyvFwDVJ2NpaSl5e3tTcHAwjRgxgqKjo6l58+YG0Y9vuvjo3r17FBcXR3Z2dlRUVKSXjG/zal8uXLiQ3N3dadSoUbR//366efMmxcTEUJs2bTSmbjDDJCIykDVFmM4UFBRg0aJFePDgAdzc3BAWFobQ0FAAdZ/ejY2N1V/v3LmD3Nxc5OTkwMnJCeHh4epPpUJnfN3q1asxZcoU5ObmokePHgaX8eTJk/Dz80Pz5s1x4MAB9OzZ0+AyZmVlYefOncjJyUFmZqZB9WNNTQ0qKyvRrFkzAHWjY/q6yOJd+1EikSAjIwOHDx9Gdna2wfSjairB48ePcffuXezZswdt27aFj48PXF1dDSLjm/z8888ICwtD165dDSKj6ti7cuUKVq5ciVu3bsHZ2RlTp05F586dDSLjq4qLi7Fx40akpqbq7Xh8WxYV1bEIAGlpadi1axeysrLQtWtXyGQySCQSveVkDcdF4kemsLAQPj4+GDRoENq1a4c9e/bA1NQUfn5+SEpKAlB3WtTMzEyvb8INzfiqR48eQSaT6eXNriEZb926hREjRmDTpk3o0qWLQWa8ffs2du7cifDwcIPpR7lcrnHK+9U3F31o6HO9detWfP3113BzczPIjPrWkIz/VmQInVF1HL548QLm5uaoqamBqampQWVUqaysRGFhIezt7eHk5PTBMwJAUVERdu/ejVGjRr112k9tba166lJlZSWKi4thZGSEFi1aoGXLlnrJyd6TgKOYTMeUSiXFxsbSiBEj1NtkMhktWLCAvLy8aNy4cRrtd+3aRaWlpQadMTMzU+9X3zYko+q0ycuXLw0+o76uIP3Yn+vXTwUaUsbG0I+GnvH110d9rC/ZkH7U92s4EdG1a9fI1taWRCIRzZs3jx49eqTVRui1Yplu8NXNHxGRSIR//vkHDx48UG+zsrLClClTMGbMGOTn52Px4sUAgOzsbEyePBkrV67U61WZ75px0qRJSE5ONviMq1atgkKh0NtITkMzKpVKvY0ef8zPtT5HOz/WfjT0jK+/Purj96Yh/ajv1/DKykokJiYiPDwcq1evxuLFi7FkyRKUlZVpPRYA+OWXX/DTTz/pLR/TLS4SPxL0/7MGevbsCYVCgcLCQvVtVlZWiI6ORo8ePdQLUoeGhiI6OhrR0dF6e7P7mDN+++23MDY21ssbyftkNDIyMuiMjeW55n7kjP+LGYG61RF69eqFkJAQTJw4Eenp6Vi6dOkbC8Xy8nLk5uYiOzsb5eXlesvIdEioIUz2YVy/fp3s7OwoOjqaKioqiOg/w/537twhkUhEu3fvFjIiZ9QRzqgbnFE3OKNuNIaMr684kJ6eTiKRiGbNmkVlZWVEVDcd48mTJ/T48WONPz7AGhcuEj9COTk5JBaLadKkSRpzRe7fv0+enp4af7dZKJxRNzijbnBG3eCMutEYMhLVFYKqAnb79u0kEokoJiaG7t27R9OmTaOIiAi9zdNmHwYXiR+prKwsEovFNHToUEpPT6eCggKaO3cuOTo6UklJidDxiIgz6gpn1A3OqBucUTcaQ0aiulFO1cVw6enpZGpqSu7u7mRiYkJ5eXkCp2Pvi4vEj1hubi4FBgaSs7Mzubq6UseOHQ3ul5Yz6gZn1A3OqBucUTcaQ0aiukJRNaLYv39/srW1pQsXLgiciukCr5P4kZPJZCgvL0dFRQUcHR1hZ2cndCQtnFE3OKNucEbd4Iy60RgyAnVrXsbExGDFihWQSqXo3r270JGYDnCRyBhjjLH3olAosGnTJvTq1QteXl5Cx2E6wkUiY4wxxt4bCfRXvNiHw+skMsYYY+y9cYH48eEikTHGGGOMaeEikTHGGGOMaeEikTHGGGOMaeEikTHGGGOMaeEikTHGGGOMaeEikTHGGGOMaeEikTHG/oVIJMKuXbsAALdu3YJIJIJUKhU0E2OM6QMXiYwxgzV27FiIRCKIRCKYmprCxcUFs2fPxsuXL4WOpqWgoAATJkxA586d0aJFC7i5uSEqKgqnTp3Savvy5UuMHTsW3bp1g4mJCSIiIt64z8OHD6Nnz54Qi8Xo0KEDNm3a9GEfBGOMvYKLRMaYQQsJCcH9+/dx8+ZNJCUlYf369Zg/f77QsTQsXrwYPj4+UCqVWLp0KY4cOYLU1FS0b98e4eHhmDdvnkZ7hUIBc3NzTJkyBUFBQW/cZ3FxMUJDQ9GvXz9IpVJMmzYN3333Hfbt26ePh8QYY1wkMsYMm1gshoODA5ycnBAREYGgoCAcOHAAAKBUKpGYmAgXFxeYm5vD09MTv//+u8b9L1++jLCwMFhbW8PKygr+/v64ceMGAODs2bMIDg6GnZ0dbGxsEBgYiLy8vHfKt2bNGmzcuBG5ublYv349QkND4eHhAT8/P8yfPx8FBQXYt28fli1bpr6PpaUlUlJSMG7cODg4OLxxv+vWrYOLiwuWLVuGzp07Y/LkyRg2bBiSkpLeKR9jjDUUF4mMsUbj0qVLOHnyJMzMzAAAiYmJ2Lx5M9atW4fLly9j+vTpGDNmDI4cOQIAuHfvHgICAiAWi5GTk4Pc3FxER0ejtrYWAFBRUYGoqCgcP34cp0+fhpubGwYPHoyKiop65SkrK0NCQgIkEgk6duwIiUQCDw8PtGrVCvHx8QgODsbVq1exfft2LFy4sN77BYBTp05pjTIOHDjwjaevGWPsQzAROgBjjP2bP//8E02bNkVtbS3kcjmMjIywevVqyOVyLFq0CAcPHoSvry8AoH379jh+/DjWr1+PwMBArFmzBjY2NkhPT4epqSkAoGPHjup99+/fX+NnbdiwAc2aNcORI0cQFhb2X7NJJBL069cP3bp1w40bNzBy5EgsW7YMffv2xerVq3Ho0CHExcXB3d0dXbt2xYkTJxASElKvx/3gwQO0bNlSY1vLli0hk8nw4sULmJub12s/jDHWUFwkMsYMWr9+/ZCSkoLKykokJSXBxMQEX331FS5fvoyqqioEBwdrtK+urkaPHj0AAFKpFP7+/uoC8XWlpaWIj4/H4cOH8fDhQygUClRVVeHOnTv1ynbx4kV89tlnAIB9+/YhICAAkyZNAgCsXbsW27dvV7d1dHTEkydP3vnxM8aYULhIZIwZNEtLS3To0AEA8Ntvv8HT0xO//vorPDw8AADZ2dlo3bq1xn3EYjEA/NfRtqioKDx+/BjJyclwdnaGWCyGr68vqqur65WttrZW/TOqq6thaWmpvs3MzEx9WlypVEIqlSImJqZe+wUABwcHlJaWamwrLS2FtbU1jyIyxvSCi0TGWKNhZGSE2NhYzJgxA0VFRRCLxbhz5w4CAwPf2L579+5IS0tDTU3NG0cTT5w4gbVr12Lw4MEAgJKSEpSVldU7T4cOHXDx4kUAgJ+fH+Li4nD69Gn07t0bKSkpePr0KWQyGWbOnInWrVujd+/e9d63r68v/vrrL41tBw4cUJ9aZ4yxD40vXGGMNSrDhw+HsbEx1q9fj1mzZmH69OlIS0vDjRs3kJeXh1WrViEtLQ0AMHnyZMhkMkRGRuLcuXO4du0atmzZgsLCQgCAm5sbtmzZgitXruDMmTMYPXr0O43ShYeHIyMjA+Xl5fD29sbcuXPh7+8PsViM/fv3o1evXoiMjMSTJ08gkUg07ltQUACpVIry8nI8e/YMUqlUY5Hu8ePH4+bNm5g9ezauXr2KtWvXYseOHZg+ffr7dyJjjNUHMcaYgYqKiqIhQ4ZobU9MTCR7e3t6/vw5rVixgtzd3cnU1JTs7e1p4MCBdOTIEXXb8+fP04ABA8jCwoKsrKzI39+fbty4QUREeXl55O3tTU2aNCE3NzfKyMggZ2dnSkpKUt8fAEkkEiIiKi4uJgCUn5+vvn3ChAk0YMAAqqysJCKiqqoqKi0tJSKi0tJSksvlb3xszs7OBEDr36sOHTpEXl5eZGZmRu3bt6fU1NR37EHGGGs4ERGRgDUqY4w1atXV1Rg+fDiuXbuGhIQEDBo0CDY2Nnj69Cl27tyJ5cuXY+/evWjTpo3QURlj7J1wkcgYY++JiJCWlobk5GRIpVKYmZlBqVTC398f8fHxWkvtMMZYY8BFImOM6dDz589RXl4Oe3t7vgqZMdaocZHIGGOMMca08NXNjDHGGGNMCxeJjDHGGGNMCxeJjDHGGGNMCxeJjDHGGGNMCxeJjDHGGGNMCxeJjDHGGGNMCxeJjDHGGGNMCxeJjDHGGGNMy/8BmEbLZTDfda4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "80 + 4 rounds rng Average Recall@10: 0.892664, qps: 145.169700\n", + "[-0.05 0.05 0.15 0.25 0.35 0.45 0.55 0.65 0.75 0.85 0.95 1.05]\n", + "[ 2782. 412. 322. 404. 604. 1031. 1780. 4053. 7309. 16390.\n", + " 64913.]\n", + "[0.02782 0.03194 0.03516 0.0392 0.04524 0.05555 0.07335 0.11388 0.18697\n", + " 0.35087 1. ]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q2d-160 Average Recall@10: 0.904002, qps: 138.753100\n", + "[1. 0.97505 0.97119 0.96819 0.96428 0.95833 0.94832 0.92966 0.88602\n", + " 0.80723 0.631 ]\n", + "[1. 0.97377 0.96974 0.96616 0.96149 0.95433 0.94177 0.91905 0.86884\n", + " 0.77954 0.59195]\n", + "[1. 0.97218 0.96806 0.96484 0.9608 0.95476 0.94445 0.92665 0.88612\n", + " 0.81303 0.64913]\n", + "80 + 4 rounds average recall: 0.903927, qps: 117.375000\n", + "80 + 4 rounds rng average recall: 0.892664, qps: 145.169700\n", + "q2d-160 average recall: 0.904002, qps: 138.753100\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import re\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Function to extract recall values from log file\n", + "def extract_recall(log_file):\n", + " recall_values = []\n", + " qps = 0\n", + " with open(log_file, 'r') as file:\n", + " for line in file:\n", + " match = re.search(r'recall:(\\d+\\.\\d+)', line)\n", + " if match:\n", + " recall_values.append(round(float(match.group(1)), 1))\n", + " # average latency is on the 2-nd last line\n", + " if line.startswith(\"[1] 0-100000\"):\n", + " qps = float(line.split()[-1]) \n", + " return recall_values, qps\n", + "\n", + "# Function to plot recall distribution\n", + "def plot_recall_distribution(recall_values, case):\n", + " # num_bins = 11\n", + " bins = np.arange(-0.05, 1.15, 0.1)\n", + " \n", + " counts, bins, patches = plt.hist(recall_values, bins=bins, edgecolor='grey', color='skyblue', zorder=10)\n", + " \n", + " print(bins)\n", + " print(counts)\n", + " total_count = sum(counts)\n", + " percentages = (counts / total_count) * 100\n", + " # calcualte cdf of counts\n", + " cdf = np.cumsum(counts)\n", + " cdf = cdf / cdf[-1]\n", + " # print cdf one by one\n", + " # print(\"cdf\")\n", + " print(cdf)\n", + " cdf = 1 - cdf\n", + " plt.title('Recall@10 Distribution of SPANN Index, Text2Image1M, %s'%case)\n", + " plt.xlabel('Recall@10')\n", + " plt.ylabel('Frequency of Queries')\n", + " \n", + "\n", + " # Set tick positions\n", + " tick_positions = bins[:-1] + (bins[1] - bins[0]) / 2\n", + " \n", + " plt.xticks(tick_positions, [f'{x:.1f}' for x in tick_positions], rotation=45)\n", + " for percent, count, x in zip(percentages, counts, tick_positions):\n", + " plt.text(x, count, f'{percent:.2f}%', ha='center', va='bottom', fontsize=8)\n", + " # plt.text(x, count, str(int(count)), ha='center', va='bottom')\n", + "\n", + " plt.grid(axis='y', alpha=0.5, linestyle='--', zorder=0)\n", + " plt.show()\n", + " return cdf\n", + "\n", + "# Function to round the values to the nearest 0.1\n", + "def round_to_nearest_tenth(values):\n", + " return np.round(values * 10) / 10\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# read files from result logs and extract the parameters from file name after \"each_\"\n", + "\n", + "# rbs = float(\"%.4f\"%(1 - cdf_spann[7]))\n", + "# print(rbs)\n", + "# tags.append(\"SPANN\")\n", + "cdfs = []\n", + "tags = []\n", + "\n", + "# cases = ['doc2doc-64', 'doc2doc-128', 'query2doc-64', 'query2doc-128']\n", + "# cases = ['64', '32', '16', '8']\n", + "# cases = ['auto-64', '4-64', '4-64', '16-64', '32-64', 'q2d-64']\n", + "cases = ['80 + 4 rounds', '80 + 4 rounds rng', 'q2d-160']\n", + "# logs = ['Release/searchlog-text2image1M-d2d-8-64', 'Release/searchlog-text2image1M-d2d-128', 'Release/searchlog-text2image1M-q2d-64', 'Release/searchlog-text2image1M-q2d-128']\n", + "# logs = ['Release/searchlog-text2image10M-d2d-64', 'Release/searchlog-text2image10M-d2d-128', 'Release/searchlog-text2image10M-q2d-64', 'Release/searchlog-text2image10M-q2d-128']\n", + "# logs = ['Release/searchlog-text2image10M-q2d-64', 'Release/searchlog-text2image10M32', 'Release/searchlog-text2image10M16', 'Release/searchlog-text2image10M8']\n", + "# logs = [\"Release/searchlog-text2image1M-d2d-auto-64\", 'Release/searchlog-text2image1M-d2d-4-64', 'Release/searchlog-text2image1M-d2d-4-64', 'Release/searchlog-text2image1M-d2d-16-64', 'Release/searchlog-text2image1M-d2d-32-64', 'Release/searchlog-text2image1M-q2d-64']\n", + "logs = ['Release/searchlog-text2image10M-d2d-internal80', 'Release/searchlog-text2image10M-d2d-internal80-rng', 'Release/searchlog-text2image10M-q2d-160']\n", + "avg_recalls = []\n", + "qpss = []\n", + "for i in range(len(cases)):\n", + " log_file = logs[i]\n", + " recall_values, qps = extract_recall(log_file)\n", + " cdf = plot_recall_distribution(recall_values, cases[i])\n", + " avg_recall = np.mean(recall_values)\n", + " print(\"%s Average Recall@10: %f, qps: %f\"%(cases[i], avg_recall, qps))\n", + " avg_recalls.append(avg_recall)\n", + " qpss.append(qps)\n", + "\n", + " cdfs.append(np.insert(cdf, 0, 1)[:-1])\n", + " tags.append(cases[i])\n", + "\n", + "\n", + "for i in range(len(cdfs)):\n", + " # plot a line for the cdf\n", + " print(cdfs[i])\n", + " plt.plot(np.arange(0.0, 1.1, 0.1), cdfs[i], linestyle='-', marker='o')\n", + "plt.xticks(np.arange(0, 1.1, 0.1))\n", + "plt.yticks(np.arange(0, 1.1, 0.1))\n", + "plt.legend(tags)\n", + "\n", + "# plt.yticks(np.arange(0.0, 1.1, 0.1))\n", + "plt.ylim(0.9, 1)\n", + "plt.yticks(np.arange(0.9, 1.01, 0.01))\n", + "\n", + "# add a grid line at x=0.8\n", + "plt.axvline(x=0.8, color='black', linestyle='--', linewidth=1)\n", + "# plt.axhline(x=0.8, color='black', linestyle='--', linewidth=1)\n", + "plt.grid(axis='y', alpha=0.5, linestyle='--', zorder=0)\n", + "plt.grid(axis='x', alpha=0.5, linestyle='--', zorder=0)\n", + "# plt.title('Cumulative Recall@10 Distribution of FAISS HNSW Index, SIFT1M')\n", + "plt.ylabel('Robustness')\n", + "plt.xlabel('Recall@10')\n", + "for i in range(len(cases)):\n", + " print(\"%s average recall: %f, qps: %f\"%(cases[i], avg_recalls[i], qpss[i]))\n", + "plt.show()\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.19" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/datasets/SPACEV1B/LICENSE b/datasets/SPACEV1B/LICENSE deleted file mode 100644 index bc492e532..000000000 --- a/datasets/SPACEV1B/LICENSE +++ /dev/null @@ -1,47 +0,0 @@ -# Open Use of Data Agreement v1.0 - -This is the Open Use of Data Agreement, Version 1.0 (the "O-UDA"). Capitalized terms are defined in Section 5. Data Provider and you agree as follows: - -1. **Provision of the Data** - - 1.1. You may use, modify, and distribute the Data made available to you by the Data Provider under this O-UDA if you follow the O-UDA's terms. - - 1.2. Data Provider will not sue you or any Downstream Recipient for any claim arising out of the use, modification, or distribution of the Data provided you meet the terms of the O-UDA. - - 1.3 This O-UDA does not restrict your use, modification, or distribution of any portions of the Data that are in the public domain or that may be used, modified, or distributed under any other legal exception or limitation. - -2. **No Restrictions on Use or Results** - - 2.1. The O-UDA does not impose any restriction with respect to: - - 2.1.1. the use or modification of Data; or - - 2.1.2. the use, modification, or distribution of Results. - -3. **Redistribution of Data** - - 3.1. You may redistribute the Data under terms of your choice, so long as: - - 3.1.1. You include with any Data you redistribute all credit or attribution information that you received with the Data, and your terms require any Downstream Recipient to do the same; and - - 3.1.2. Your terms include a warranty disclaimer and limitation of liability for Upstream Data Providers at least as broad as those contained in Section 4.2 and 4.3 of the O-UDA. - -4. **No Warranty, Limitation of Liability** - - 4.1. Data Provider does not represent or warrant that it has any rights whatsoever in the Data. - - 4.2. THE DATA IS PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. - - 4.3. NEITHER DATA PROVIDER NOR ANY UPSTREAM DATA PROVIDER SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE DATA OR RESULTS, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. - -5. **Definitions** - - 5.1. "Data" means the material you receive under the O-UDA in modified or unmodified form, but not including Results. - - 5.2. "Data Provider" means the source from which you receive the Data and with whom you enter into the O-UDA. - - 5.3. "Downstream Recipient" means any person or persons who receives the Data directly or indirectly from you in accordance with the O-UDA. - - 5.4. "Result" means anything that you develop or improve from your use of Data that does not include more than a de minimis portion of the Data on which the use is based. Results may include de minimis portions of the Data necessary to report on or explain use that has been conducted with the Data, such as figures in scientific papers, but do not include more. Artificial intelligence models trained on Data (and which do not include more than a de minimis portion of Data) are Results. - - 5.5. "Upstream Data Providers" means the source or sources from which the Data Provider directly or indirectly received, under the terms of the O-UDA, material that is included in the Data. diff --git a/datasets/SPACEV1B/README.md b/datasets/SPACEV1B/README.md deleted file mode 100644 index 034c684a7..000000000 --- a/datasets/SPACEV1B/README.md +++ /dev/null @@ -1,52 +0,0 @@ -# SPACEV1B: A billion-Scale vector dataset for text descriptors -This is a dataset released by Microsoft from SpaceV, Bing web vector search scenario, for large scale vector search related research usage. It consists of more than one billion document vectors -and 29K+ query vectors encoded by Microsoft SpaceV Superior model. This model is trained to capture generic intent representation for both documents and queries. -The goal is to match the query vector to the closest document vectors in order to achieve topk relevant documents for each query. - -## Introduction - -This dataset contains: - - * [vectors.bin](vectors.bin): It contains 1,402,020,720 100-dimensional int8-type document descriptors. - * [query.bin](query.bin): It contains 29,316 100-dimensional int8-type query descriptors. - * [truth.bin](truth.bin): It contains 100 nearest ground truth（include vector ids and distances) of 29,316 queries according to L2 distance. - * [query_log.bin](query_log.bin): It contains 94,162 100-dimensional int8-type history query descriptors. - -## How to read the vectors, queries, and truth - -```python -import struct -import numpy as np -import os - -part_count = len(os.listdir('vectors.bin')) -for i in range(1, part_count + 1): - fvec = open(os.path.join('vectors.bin', 'vectors_%d.bin' % i), 'rb') - if i == 1: - vec_count = struct.unpack('i', fvec.read(4))[0] - vec_dimension = struct.unpack('i', fvec.read(4))[0] - vecbuf = bytearray(vec_count * vec_dimension) - vecbuf_offset = 0 - while True: - part = fvec.read(1048576) - if len(part) == 0: break - vecbuf[vecbuf_offset: vecbuf_offset + len(part)] = part - vecbuf_offset += len(part) - fvec.close() -X = np.frombuffer(vecbuf, dtype=np.int8).reshape((vec_count, vec_dimension)) - -fq = open('query.bin', 'rb') -q_count = struct.unpack('i', fq.read(4))[0] -q_dimension = struct.unpack('i', fq.read(4))[0] -queries = np.frombuffer(fq.read(q_count * q_dimension), dtype=np.int8).reshape((q_count, q_dimension)) - -ftruth = open('truth.bin', 'rb') -t_count = struct.unpack('i', ftruth.read(4))[0] -topk = struct.unpack('i', ftruth.read(4))[0] -truth_vids = np.frombuffer(ftruth.read(t_count * topk * 4), dtype=np.int32).reshape((t_count, topk)) -truth_distances = np.frombuffer(ftruth.read(t_count * topk * 4), dtype=np.float32).reshape((t_count, topk)) -``` - -## License - -The entire dataset is under [O-UDA license](LICENSE) \ No newline at end of file diff --git a/datasets/SPACEV1B/query.bin b/datasets/SPACEV1B/query.bin deleted file mode 100644 index bba5be6bc..000000000 --- a/datasets/SPACEV1B/query.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:6a531887daca721f633da2b92dacc0aa4c3512aef8ae671031e825ce7134a9e6 -size 2931608 diff --git a/datasets/SPACEV1B/query_log.bin b/datasets/SPACEV1B/query_log.bin deleted file mode 100644 index 25102b7f4..000000000 --- a/datasets/SPACEV1B/query_log.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:d4768ea964b595302b08f0b9ef484d7003b2e7848f2f7baf9e2b4bbb3bb36c49 -size 9416208 diff --git a/datasets/SPACEV1B/truth.bin b/datasets/SPACEV1B/truth.bin deleted file mode 100644 index 127acd278..000000000 --- a/datasets/SPACEV1B/truth.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:94d385c2f34b1f2899f276d87c14a67ef969dcb473e44753261af05ad62461bc -size 23452808 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_1.bin b/datasets/SPACEV1B/vectors.bin/vectors_1.bin deleted file mode 100644 index 459d509f8..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_1.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:802f735e6bd1472bacdd93eedf8d1305291659117c2b5e3ca9ac38feb89509af -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_10.bin b/datasets/SPACEV1B/vectors.bin/vectors_10.bin deleted file mode 100644 index f2cc9f7fd..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_10.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:ca7053c8582853c7a9984b56be8b9954cd8cbeda159b9b63fa5a56f776561be2 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_11.bin b/datasets/SPACEV1B/vectors.bin/vectors_11.bin deleted file mode 100644 index 260aec2f3..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_11.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:b42ee98dbdf215d9c03e99d3c3ac401e615433d70119c7411c689884159773d1 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_12.bin b/datasets/SPACEV1B/vectors.bin/vectors_12.bin deleted file mode 100644 index dc8ddcada..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_12.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:0dd7f1a25a6aa53622fa3d66a35af760bccd187a82bbe39a0bf79c681b646289 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_13.bin b/datasets/SPACEV1B/vectors.bin/vectors_13.bin deleted file mode 100644 index 40261a566..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_13.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:69d09f33ba230ee9b38e6fc1bf949c7f57b755c49ae8cdaf13ebf14b12272fe5 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_14.bin b/datasets/SPACEV1B/vectors.bin/vectors_14.bin deleted file mode 100644 index 9374d4aea..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_14.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:d575a0ec126bfd3ffb6a3dfb7c36ad94c71a398c0a77b0462620feaa7181cbfb -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_15.bin b/datasets/SPACEV1B/vectors.bin/vectors_15.bin deleted file mode 100644 index 91ffea633..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_15.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:0286768443fbdd55ec0ffd25cecf85121aafef6c65226dc2008dda2ece5c7c8e -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_16.bin b/datasets/SPACEV1B/vectors.bin/vectors_16.bin deleted file mode 100644 index 85affbcfd..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_16.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:b600774407a1446fcac0748c7beb5fa4214737bf406c2a162ccbb84254c5041d -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_17.bin b/datasets/SPACEV1B/vectors.bin/vectors_17.bin deleted file mode 100644 index efc0af471..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_17.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:5fb2167810380da46d894428ff8f2c61de05c9616a6343f1fa6d084759abb062 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_18.bin b/datasets/SPACEV1B/vectors.bin/vectors_18.bin deleted file mode 100644 index 78fadc980..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_18.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:d2e69b2f20fb99063944379667b8b9dc33d672079fe6e744d83076c2de5b1ecc -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_19.bin b/datasets/SPACEV1B/vectors.bin/vectors_19.bin deleted file mode 100644 index ad536394f..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_19.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:1942f09f15c34c1e141a2bdb31138efcfda9a9fe5671c757e6b6a2e509864d65 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_2.bin b/datasets/SPACEV1B/vectors.bin/vectors_2.bin deleted file mode 100644 index adc632530..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_2.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:c8f772d430aa817bbd60319486dce7390924a7b71c3038312c89ab93a6382d43 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_20.bin b/datasets/SPACEV1B/vectors.bin/vectors_20.bin deleted file mode 100644 index 5e75632cb..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_20.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:2becd2dcedb147d6c3927fa3b6f2d0f5ede03870efad8c8d04055e25694d60b2 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_21.bin b/datasets/SPACEV1B/vectors.bin/vectors_21.bin deleted file mode 100644 index 308424ed3..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_21.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:0cc41b1a8f6b3fb8ef87dd918b8f12433f1a4bac5711260e6722e9172de14754 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_22.bin b/datasets/SPACEV1B/vectors.bin/vectors_22.bin deleted file mode 100644 index d5e137c2d..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_22.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:8cb1780b449120a124d71d4a6e5268c1ac2ec57bf27bb37c23a859b41702f3b8 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_23.bin b/datasets/SPACEV1B/vectors.bin/vectors_23.bin deleted file mode 100644 index 3ad0234a6..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_23.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:b04df15421deb05670f21f34a26b4c0d108e5dd0bc8e3024701e46a90bd2d222 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_24.bin b/datasets/SPACEV1B/vectors.bin/vectors_24.bin deleted file mode 100644 index eb4ea18c6..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_24.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:2ec09e657776aec02783886de7448642a85ddb004d70df0d10537a7837d076f5 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_25.bin b/datasets/SPACEV1B/vectors.bin/vectors_25.bin deleted file mode 100644 index 49d0e7963..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_25.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:a4a3c0ccf4da399397f01748b54f686a416cd5719c126ec93ce9effa124debe3 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_26.bin b/datasets/SPACEV1B/vectors.bin/vectors_26.bin deleted file mode 100644 index 416d5aa75..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_26.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:20c541f53d1e0772a270df12543dc0d715b4edb17ca415ebdf45065d2440525f -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_27.bin b/datasets/SPACEV1B/vectors.bin/vectors_27.bin deleted file mode 100644 index dc04c379a..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_27.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:69c820cd585cb7883e6489e1e96f8a943be7800bb21e25ed88cff1b63a11a660 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_28.bin b/datasets/SPACEV1B/vectors.bin/vectors_28.bin deleted file mode 100644 index cfeff8cd4..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_28.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:d82070201cb0b34fa38579118ad01ba13efb62d8b45e30867ab763e7794ced54 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_29.bin b/datasets/SPACEV1B/vectors.bin/vectors_29.bin deleted file mode 100644 index 05e30128b..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_29.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:a11ce9f677543ab2f4b71d199e41e2026020c23a47147f536cbdd93a4266fcd8 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_3.bin b/datasets/SPACEV1B/vectors.bin/vectors_3.bin deleted file mode 100644 index 61e39be36..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_3.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:787c77685a1603d4aa7f2b4b7f9e19ddff2d828ea21554aca52c82e8d7a6a755 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_30.bin b/datasets/SPACEV1B/vectors.bin/vectors_30.bin deleted file mode 100644 index 5b6f9030a..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_30.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:e426936bcc481e878b6f7ec32c1cb85438d23f63c0dd27330149f64053475a8d -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_31.bin b/datasets/SPACEV1B/vectors.bin/vectors_31.bin deleted file mode 100644 index d7d461021..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_31.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:351d25192805efc17f8fc588c872b907ca2b907ca9cb0d3f1413ea1d8fc09a8f -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_32.bin b/datasets/SPACEV1B/vectors.bin/vectors_32.bin deleted file mode 100644 index bd1bde4e6..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_32.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:142c672c7c1f1e0df93ac87a3d39466c9a7fb199309761ba21771bb1f5d2de86 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_33.bin b/datasets/SPACEV1B/vectors.bin/vectors_33.bin deleted file mode 100644 index 3b0c28771..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_33.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:e7bb8962700f6b240481d462a6e0f1a997d085857690cf63b5b5be9270e17b5e -size 2763118568 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_4.bin b/datasets/SPACEV1B/vectors.bin/vectors_4.bin deleted file mode 100644 index c09f47ea0..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_4.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:d2f3526062048781bdc36d3b0c80ce49c26a4874206109ff79064de2b3acc4dc -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_5.bin b/datasets/SPACEV1B/vectors.bin/vectors_5.bin deleted file mode 100644 index 40ce70e39..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_5.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:7b94a7e08eb31cf2fbe7d24b1e12b23f1341a75aeed96e4885f288333fdfdfbc -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_6.bin b/datasets/SPACEV1B/vectors.bin/vectors_6.bin deleted file mode 100644 index 8cac0cb9f..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_6.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:a2b2699313be8e6ca09dc67b3267b6bf42ab2ac350c1198041b2fa9778b7905c -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_7.bin b/datasets/SPACEV1B/vectors.bin/vectors_7.bin deleted file mode 100644 index 089611283..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_7.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:7960bac8a7579fcaf27a17271a49d0d61f13bbf6397712f513892e84fe89a7d0 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_8.bin b/datasets/SPACEV1B/vectors.bin/vectors_8.bin deleted file mode 100644 index 4240d9cd8..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_8.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:6f968cbd5bd1eb53722373ffedeb6bed9659a69a01df030e39f67a755418ca45 -size 4294967295 diff --git a/datasets/SPACEV1B/vectors.bin/vectors_9.bin b/datasets/SPACEV1B/vectors.bin/vectors_9.bin deleted file mode 100644 index d075a1a59..000000000 --- a/datasets/SPACEV1B/vectors.bin/vectors_9.bin +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:f50e029134bc17703be6bc69748953ef2c9bb81b29d2286bda4d006d8bfce34c -size 4294967295 diff --git a/docs/Tutorial.ipynb b/docs/Tutorial.ipynb index 0cc1c0927..e1e59c542 100644 --- a/docs/Tutorial.ipynb +++ b/docs/Tutorial.ipynb @@ -17,7 +17,28 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "\n", + "# Print the current PYTHONPATH\n", + "print(os.environ.get('PYTHONPATH'))\n", + "\n", + "# Set the PYTHONPATH if necessary\n", + "os.environ['PYTHONPATH'] = '/home/v-zikaiwang/SPTAG/Release'\n", + "sys.path.append('/home/v-zikaiwang/SPTAG/Release')\n", + "\n", + "# Verify by importing SPTAG again\n", + "import SPTAG\n", + "print(SPTAG.__file__)" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -46,28 +67,24 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['deletes.bin',\n", - " 'graph.bin',\n", - " 'indexloader.ini',\n", - " 'metadata.bin',\n", - " 'metadataIndex.bin',\n", - " 'tree.bin',\n", - " 'vectors.bin']" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ + "import sys\n", + "import os\n", + "\n", + "# Print the current PYTHONPATH\n", + "print(os.environ.get('PYTHONPATH'))\n", + "\n", + "# Set the PYTHONPATH if necessary\n", + "os.environ['PYTHONPATH'] = '/home/v-zikaiwang/SPTAG/Release'\n", + "sys.path.append('/home/v-zikaiwang/SPTAG/Release')\n", + "\n", + "# Verify by importing SPTAG again\n", "import SPTAG\n", + "print(SPTAG.__file__)\n", + "# import SPTAG\n", "\n", "index = SPTAG.AnnIndex('BKT', 'Float', vector_dimension)\n", "\n", @@ -87,20 +104,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[450, 247, 150, 832, 626, 828, 253, 471, 243, 365]\n", - "[11.603649139404297, 12.164414405822754, 12.225785255432129, 12.336504936218262, 12.416375160217285, 12.481977462768555, 12.573633193969727, 12.616722106933594, 12.708147048950195, 12.821012496948242]\n", - "[b'450\\n', b'247\\n', b'150\\n', b'832\\n', b'626\\n', b'828\\n', b'253\\n', b'471\\n', b'243\\n', b'365\\n']\n", - "[(450, 11.603649139404297, b'450\\n'), (247, 12.164414405822754, b'247\\n'), (150, 12.225785255432129, b'150\\n'), (832, 12.336504936218262, b'832\\n'), (626, 12.416375160217285, b'626\\n'), (828, 12.481977462768555, b'828\\n'), (253, 12.573633193969727, b'253\\n'), (471, 12.616722106933594, b'471\\n'), (243, 12.708147048950195, b'243\\n'), (365, 12.821012496948242, b'365\\n')]\n" - ] - } - ], + "outputs": [], "source": [ "# Local index test on the vector search\n", "index = SPTAG.AnnIndex.Load('sptag_index')\n", @@ -108,7 +114,8 @@ "# prepare query vector\n", "q = np.random.rand(vector_dimension).astype(np.float32)\n", "\n", - "result = index.SearchWithMetaData(q, 10) # Search k=3 nearest vectors for query vector q\n", + "# result = index.SearchWithMetaData(q, 10) # Search k=3 nearest vectors for query vector q\n", + "result = index.Search(q, 10) # Search k=3 nearest vectors for query vector q\n", "print (result[0]) # nearest k vector ids\n", "print (result[1]) # nearest k vector distances\n", "print (result[2]) # nearest k vector metadatas\n", @@ -139,18 +146,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CompletedProcess(args='Quantizer.exe -d 100 -v Float -f DEFAULT -i sptag_index\\\\vectors.bin -o quan_doc_vectors.bin -oq quantizer.bin -qt PQQuantizer -qd 50 -ts 1000 -norm false', returncode=0)\n", - "(1000, 50)\n" - ] - } - ], + "outputs": [], "source": [ "import subprocess\n", "import struct\n", @@ -177,27 +175,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['deletes.bin',\n", - " 'graph.bin',\n", - " 'indexloader.ini',\n", - " 'metadata.bin',\n", - " 'metadataIndex.bin',\n", - " 'quantizer.bin',\n", - " 'tree.bin',\n", - " 'vectors.bin']" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import SPTAG\n", "\n", @@ -219,19 +199,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[450, 247, 832, 626, 150, 253, 471, 828, 243, 207, 365, 823]\n", - "[11.497368812561035, 12.21573257446289, 12.328060150146484, 12.369790077209473, 12.420766830444336, 12.47612476348877, 12.48221206665039, 12.526467323303223, 12.802266120910645, 12.819355010986328, 12.876933097839355, 12.913871765136719]\n", - "[b'450\\n', b'247\\n', b'832\\n', b'626\\n', b'150\\n', b'253\\n', b'471\\n', b'828\\n', b'243\\n', b'207\\n', b'365\\n', b'823\\n']\n" - ] - } - ], + "outputs": [], "source": [ "# Local index test on the vector search\n", "index = SPTAG.AnnIndex.Load('quan_sptag_index')\n", @@ -244,26 +214,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['HeadIndex',\n", - " 'indexloader.ini',\n", - " 'metadata.bin',\n", - " 'metadataIndex.bin',\n", - " 'SPTAGFullList.bin',\n", - " 'SPTAGHeadVectorIDs.bin',\n", - " 'SPTAGHeadVectors.bin']" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import SPTAG\n", "\n", @@ -301,19 +254,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[450, 247, 150, 832, 626, 828, 253, 471, 243, 365, 207, 823]\n", - "[11.603649139404297, 12.164414405822754, 12.225785255432129, 12.336504936218262, 12.416375160217285, 12.481977462768555, 12.573633193969727, 12.616722106933594, 12.708147048950195, 12.821012496948242, 12.878414154052734, 13.01927375793457]\n", - "[b'450\\n', b'247\\n', b'150\\n', b'832\\n', b'626\\n', b'828\\n', b'253\\n', b'471\\n', b'243\\n', b'365\\n', b'207\\n', b'823\\n']\n" - ] - } - ], + "outputs": [], "source": [ "index = SPTAG.AnnIndex.Load('spann_index')\n", "result = index.SearchWithMetaData(q, 12) # Search k=3 nearest vectors for query vector q\n", @@ -324,27 +267,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['HeadIndex',\n", - " 'indexloader.ini',\n", - " 'metadata.bin',\n", - " 'metadataIndex.bin',\n", - " 'quantizer.bin',\n", - " 'SPTAGFullList.bin',\n", - " 'SPTAGHeadVectorIDs.bin',\n", - " 'SPTAGHeadVectors.bin']" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import SPTAG\n", "\n", @@ -383,19 +308,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[450, 247, 832, 626, 150, 253, 471, 828, 243, 207, 365, 823]\n", - "[11.497368812561035, 12.21573257446289, 12.328060150146484, 12.369790077209473, 12.420766830444336, 12.47612476348877, 12.48221206665039, 12.526467323303223, 12.802266120910645, 12.819355010986328, 12.876933097839355, 12.913871765136719]\n", - "[b'450\\n', b'247\\n', b'832\\n', b'626\\n', b'150\\n', b'253\\n', b'471\\n', b'828\\n', b'243\\n', b'207\\n', b'365\\n', b'823\\n']\n" - ] - } - ], + "outputs": [], "source": [ "index = SPTAG.AnnIndex.Load('spann_quan_index')\n", "index.SetQuantizerADC(True)\n", @@ -527,7 +442,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.3" + "version": "3.10.12" }, "mimetype": "text/x-python", "name": "python",