diff --git a/search/categories_set.hpp b/search/categories_set.hpp
index 343d1c40b9..1308f5caf0 100644
--- a/search/categories_set.hpp
+++ b/search/categories_set.hpp
@@ -4,65 +4,40 @@
 #include "indexer/search_string_utils.hpp"
 
 #include "base/macros.hpp"
-#include "base/stl_helpers.hpp"
 #include "base/string_utils.hpp"
 
 #include "std/algorithm.hpp"
 #include "std/cstdint.hpp"
-#include "std/vector.hpp"
+#include "std/map.hpp"
 
 namespace search
 {
-struct Category
-{
-  Category(strings::UniString const & key, uint32_t type) : m_key(key), m_type(type) {}
-
-  bool operator==(Category const & rhs) const { return m_key == rhs.m_key && m_type == rhs.m_type; }
-
-  bool operator<(Category const & rhs) const
-  {
-    if (m_key != rhs.m_key)
-      return m_key < rhs.m_key;
-    return m_type < rhs.m_type;
-  }
-
-  strings::UniString m_key;
-  uint32_t m_type = 0;
-};
-
 class CategoriesSet
 {
 public:
-  template <typename TTypesList>
-  CategoriesSet(TTypesList const & typesList)
+  CategoriesSet() : m_classificator(classif()) {}
+
+  void Add(uint32_t type)
   {
-    auto const & classificator = classif();
-
-    auto addCategory = [&](uint32_t type) {
-      uint32_t const index = classificator.GetIndexForType(type);
-      m_categories.emplace_back(FeatureTypeToString(index), type);
-    };
-
-    typesList.ForEachType(addCategory);
-
-    my::SortUnique(m_categories);
+    uint32_t const index = m_classificator.GetIndexForType(type);
+    m_categories[FeatureTypeToString(index)] = type;
   }
 
   template <typename TFn>
   void ForEach(TFn && fn) const
   {
-    for_each(m_categories.cbegin(), m_categories.cend(), forward<TFn>(fn));
+    for (auto const & p : m_categories)
+      fn(p.first, p.second);
   }
 
   bool HasKey(strings::UniString const & key) const
   {
-    auto const it =
-        lower_bound(m_categories.cbegin(), m_categories.cend(), Category(key, 0 /* type */));
-    return it != m_categories.cend() && it->m_key == key;
+    return m_categories.count(key) != 0;
   }
 
 private:
-  vector<Category> m_categories;
+  Classificator const & m_classificator;
+  map<strings::UniString, uint32_t> m_categories;
 
   DISALLOW_COPY_AND_MOVE(CategoriesSet);
 };
diff --git a/search/geocoder.cpp b/search/geocoder.cpp
index f66d5136ea..2658e33300 100644
--- a/search/geocoder.cpp
+++ b/search/geocoder.cpp
@@ -362,8 +362,6 @@ Geocoder::Geocoder(Index const & index, storage::CountryInfoGetter const & infoG
   : m_index(index)
   , m_infoGetter(infoGetter)
   , m_cancellable(cancellable)
-  , m_streets(ftypes::IsStreetChecker::Instance())
-  , m_villages(ftypes::IsVillageChecker::Instance())
   , m_model(SearchModel::Instance())
   , m_pivotRectsCache(kPivotRectsCacheSize, m_cancellable, Processor::kMaxViewportRadiusM)
   , m_localityRectsCache(kLocalityRectsCacheSize, m_cancellable)
@@ -373,6 +371,8 @@ Geocoder::Geocoder(Index const & index, storage::CountryInfoGetter const & infoG
   , m_lastMatchedRegion(nullptr)
   , m_preRanker(preRanker)
 {
+  ftypes::IsStreetChecker::Instance().ForEachType([this](uint32_t type) { m_streets.Add(type); });
+  ftypes::IsVillageChecker::Instance().ForEachType([this](uint32_t type) { m_villages.Add(type); });
 }
 
 Geocoder::~Geocoder() {}
@@ -408,7 +408,11 @@ void Geocoder::SetParams(Params const & params)
     {
       auto b = synonyms.begin();
       auto e = synonyms.end();
-      synonyms.erase(remove_if(b + 1, e, bind(&CategoriesSet::HasKey, cref(m_streets), _1)), e);
+      synonyms.erase(remove_if(b + 1, e,
+                               [this](strings::UniString const & synonym) {
+                                 return m_streets.HasKey(synonym);
+                               }),
+                     e);
     }
   }
 
@@ -1375,9 +1379,9 @@ CBV Geocoder::LoadCategories(MwmContext & context, CategoriesSet const & categor
 
   vector<CBV> cbvs;
 
-  categories.ForEach([&](Category const & category) {
-    m_retrievalParams.m_tokens[0][0] = category.m_key;
-    m_retrievalParams.m_types[0][0] = category.m_type;
+  categories.ForEach([&](strings::UniString const & key, uint32_t const type) {
+    m_retrievalParams.m_tokens[0][0] = key;
+    m_retrievalParams.m_types[0][0] = type;
 
     CBV cbv(RetrieveAddressFeatures(context, m_cancellable, m_retrievalParams));
     if (!cbv.IsEmpty())
diff --git a/search/query_params.hpp b/search/query_params.hpp
index 4d537a7a8e..9a08185f21 100644
--- a/search/query_params.hpp
+++ b/search/query_params.hpp
@@ -34,7 +34,7 @@ struct QueryParams
   TSynonymsVector const & GetTokens(size_t i) const;
   TSynonymsVector & GetTokens(size_t i);
 
-  // Returns true if all tokens in [start, end) range has intergral
+  // Returns true if all tokens in [start, end) range have integral
   // synonyms.
   bool IsNumberTokens(size_t start, size_t end) const;
 
diff --git a/search/retrieval.cpp b/search/retrieval.cpp
index 4f77bf35d5..fb0587d3a4 100644
--- a/search/retrieval.cpp
+++ b/search/retrieval.cpp
@@ -149,16 +149,16 @@ bool MatchFeatureByNameAndType(FeatureType const & ft, QueryParams const & param
 
     for (size_t i = 0; i < params.GetNumTokens(); ++i)
     {
-      bool const isPrefix = params.IsPrefixToken(i);
+      auto const isPrefix = params.IsPrefixToken(i);
       auto const & syms = params.GetTokens(i);
 
       if (!IsFirstMatchesSecond(nameTokens, syms, isPrefix ? prefixMatch : fullMatch))
       {
         // Checks types in case of names mismatch.
         auto const & types = params.m_types[i];
-        bool typeMatched = false;
+        auto typeMatched = false;
 
-        for (auto const type : types)
+        for (auto const & type : types)
         {
           if (th.Has(type))
           {
diff --git a/search/search_integration_tests/search_edited_features_test.cpp b/search/search_integration_tests/search_edited_features_test.cpp
index 5f8d70eb6a..bd3ed5c7f0 100644
--- a/search/search_integration_tests/search_edited_features_test.cpp
+++ b/search/search_integration_tests/search_edited_features_test.cpp
@@ -17,8 +17,6 @@ using namespace generator::tests_support;
 using namespace search::tests_support;
 using namespace search;
 
-using TRules = vector<shared_ptr<MatchingRule>>;
-
 namespace
 {
 class SearchEditedFeaturesTest : public SearchTest