diff --git a/coding/read_write_utils.hpp b/coding/read_write_utils.hpp
index 81d2dd0008..1ff8123c7a 100644
--- a/coding/read_write_utils.hpp
+++ b/coding/read_write_utils.hpp
@@ -25,22 +25,6 @@ namespace rw
     i = ReadVarUint<uint32_t>(src);
   }
 
-  template <class TSink, class T>
-  void WritePOD(TSink & sink, T const & value)
-  {
-    static_assert(std::is_trivially_copyable<T>::value, "");
-
-    sink.Write(&value, sizeof(T));
-  }
-
-  template <class TSource, class T>
-  void ReadPOD(TSource & src, T & value)
-  {
-    static_assert(std::is_trivially_copyable<T>::value, "");
-
-    src.Read(&value, sizeof(T));
-  }
-
   template <class TSink>
   void Write(TSink & sink, std::string const & s)
   {
diff --git a/generator/affiliation.cpp b/generator/affiliation.cpp
index a21ab6540b..eb41927fba 100644
--- a/generator/affiliation.cpp
+++ b/generator/affiliation.cpp
@@ -2,9 +2,9 @@
 
 namespace feature
 {
-CountriesFilesAffiliation::CountriesFilesAffiliation(std::string const & borderPath, bool isMwmsForWholeWorld)
+CountriesFilesAffiliation::CountriesFilesAffiliation(std::string const & borderPath, bool haveBordersForWholeWorld)
   : m_countries(borders::PackedBorders::GetOrCreate(borderPath))
-  , m_isMwmsForWholeWorld(isMwmsForWholeWorld)
+  , m_haveBordersForWholeWorld(haveBordersForWholeWorld)
 {
 }
 
@@ -16,25 +16,23 @@ std::vector<std::string> CountriesFilesAffiliation::GetAffiliations(FeatureBuild
     countriesContainer.emplace_back(countryPolygons);
   });
 
-  if (m_isMwmsForWholeWorld && countriesContainer.size() == 1)
+  // todo(m.andrianov): We need to explore this optimization better. There is a hypothesis: some
+  // elements belong to a rectangle, but do not belong to the exact boundary.
+  if (m_haveBordersForWholeWorld && countriesContainer.size() == 1)
   {
-    borders::CountryPolygons const & countryPolygons= countriesContainer.front();
+    borders::CountryPolygons const & countryPolygons = countriesContainer.front();
     countries.emplace_back(countryPolygons.GetName());
     return countries;
   }
 
-  if (!countriesContainer.empty())
+  for (borders::CountryPolygons const & countryPolygons : countriesContainer)
   {
-    for (borders::CountryPolygons const & countryPolygons : countriesContainer)
-    {
-      auto const need = fb.ForAnyGeometryPoint([&](auto const & point) {
-        return countryPolygons.Contains(point);
-      });
+    auto const need = fb.ForAnyGeometryPoint([&](auto const & point) {
+      return countryPolygons.Contains(point);
+    });
 
-      if (need)
-        countries.emplace_back(countryPolygons.GetName());
-    }
-    return countries;
+    if (need)
+      countries.emplace_back(countryPolygons.GetName());
   }
 
   return countries;
@@ -45,17 +43,17 @@ bool CountriesFilesAffiliation::HasRegionByName(std::string const & name) const
   return m_countries.HasRegionByName(name);
 }
 
-OneFileAffiliation::OneFileAffiliation(std::string const & filename)
+SingleAffiliation::SingleAffiliation(std::string const & filename)
   : m_filename(filename)
 {
 }
 
-std::vector<std::string> OneFileAffiliation::GetAffiliations(FeatureBuilder const &) const
+std::vector<std::string> SingleAffiliation::GetAffiliations(FeatureBuilder const &) const
 {
   return {m_filename};
 }
 
-bool OneFileAffiliation::HasRegionByName(std::string const & name) const
+bool SingleAffiliation::HasRegionByName(std::string const & name) const
 {
   return name == m_filename;
 }
diff --git a/generator/affiliation.hpp b/generator/affiliation.hpp
index dcd7ebc22b..9229349d88 100644
--- a/generator/affiliation.hpp
+++ b/generator/affiliation.hpp
@@ -13,6 +13,7 @@ class AffiliationInterface
 public:
   virtual ~AffiliationInterface() = default;
 
+  // The method will return the names of the buckets to which the fb belongs.
   virtual std::vector<std::string> GetAffiliations(FeatureBuilder const & fb) const = 0;
   virtual bool HasRegionByName(std::string const & name) const = 0;
 };
@@ -20,26 +21,24 @@ public:
 class CountriesFilesAffiliation : public AffiliationInterface
 {
 public:
-  CountriesFilesAffiliation(std::string const & borderPath, bool isMwmsForWholeWorld);
+  CountriesFilesAffiliation(std::string const & borderPath, bool haveBordersForWholeWorld);
 
   // AffiliationInterface overrides:
   std::vector<std::string> GetAffiliations(FeatureBuilder const & fb) const override;
-
   bool HasRegionByName(std::string const & name) const override;
 
 private:
   borders::CountriesContainer const & m_countries;
-  bool m_isMwmsForWholeWorld;
+  bool m_haveBordersForWholeWorld;
 };
 
-class OneFileAffiliation : public AffiliationInterface
+class SingleAffiliation : public AffiliationInterface
 {
 public:
-  OneFileAffiliation(std::string const & filename);
+  SingleAffiliation(std::string const & filename);
 
   // AffiliationInterface overrides:
   std::vector<std::string> GetAffiliations(FeatureBuilder const &) const override;
-
   bool HasRegionByName(std::string const & name) const override;
 
 private:
diff --git a/generator/borders.cpp b/generator/borders.cpp
index fea17c9a10..2d87045625 100644
--- a/generator/borders.cpp
+++ b/generator/borders.cpp
@@ -304,12 +304,13 @@ std::unordered_map<std::string, CountriesContainer> PackedBorders::m_countries;
 CountriesContainer const & PackedBorders::GetOrCreate(std::string const & name)
 {
   std::lock_guard<std::mutex> lock(m_mutex);
-  if (m_countries.count(name) != 0)
-    return m_countries[name];
+  auto const it = m_countries.find(name);
+  if (it != m_countries.cend())
+    return it->second;
 
   CountriesContainer countries;
   CHECK(LoadCountriesList(name, countries), ("Error loading country polygons files."));
-  m_countries.emplace(name, countries);
-  return m_countries[name];
+  auto const eIt = m_countries.emplace(name, countries);
+  return eIt.first->second;
 }
 }  // namespace borders
diff --git a/generator/borders.hpp b/generator/borders.hpp
index fef8b7d89d..8ad88c921f 100644
--- a/generator/borders.hpp
+++ b/generator/borders.hpp
@@ -9,8 +9,6 @@
 #include "geometry/region2d.hpp"
 #include "geometry/tree4d.hpp"
 
-#include <string>
-
 #include <memory>
 #include <mutex>
 #include <string>
@@ -46,9 +44,9 @@ class CountryPolygons
 {
 public:
   CountryPolygons() = default;
-  explicit CountryPolygons( std::string const & name, RegionsContainer const & regions)
-      : m_name(name)
-      , m_regions(regions)
+  explicit CountryPolygons(std::string const & name, RegionsContainer const & regions)
+    : m_name(name)
+    , m_regions(regions)
   {
   }
 
@@ -88,9 +86,6 @@ public:
   explicit CountriesContainer(m4::Tree<CountryPolygons> const & tree)
     : m_regionsTree(tree)
   {
-    tree.ForEach([&](auto const & region) {
-      m_regions.emplace(region.GetName(), region);
-    });
   }
 
   template <typename ToDo>
@@ -101,24 +96,37 @@ public:
 
   bool HasRegionByName(std::string const & name) const
   {
-    return m_regions.count(name) != 0;
+    return m_regionsTree.FindNode([&](auto const & countryPolygons) {
+      return countryPolygons.GetName() == name;
+    });
   }
 
-    // TODO(maksimandrianov): Remove it, after removing Polygonizer class.
+  // TODO(maksimandrianov): Remove it, after removing Polygonizer class.
   void Add(CountryPolygons const & country, m2::RectD const & rect)
   {
-    m_regions.emplace(country.GetName(), country);
     m_regionsTree.Add(country, rect);
   }
 
   CountryPolygons const & GetRegionByName(std::string const & name) const
   {
-    return m_regions.at(name);
+    ASSERT(HasRegionByName(name), ());
+
+    CountryPolygons const * country = nullptr;
+    m_regionsTree.FindNode([&](auto const & countryPolygons) {
+      if (countryPolygons.GetName() == name)
+      {
+        country = &countryPolygons;
+        return true;
+      }
+
+      return false;
+    });
+
+    return *country;
   }
 
 private:
   m4::Tree<CountryPolygons> m_regionsTree;
-  std::unordered_map<std::string, CountryPolygons> m_regions;
 };
 
 /// @return false if borderFile can't be opened
diff --git a/generator/feature_builder.cpp b/generator/feature_builder.cpp
index 61eaecb74c..51cb74b748 100644
--- a/generator/feature_builder.cpp
+++ b/generator/feature_builder.cpp
@@ -13,6 +13,8 @@
 #include "coding/bit_streams.hpp"
 #include "coding/byte_stream.hpp"
 #include "coding/geometry_coding.hpp"
+#include "coding/read_write_utils.hpp"
+#include "coding/reader.hpp"
 
 #include "geometry/region2d.hpp"
 
@@ -51,6 +53,22 @@ bool IsEqual(vector<m2::PointD> const & v1, vector<m2::PointD> const & v2)
   return equal(cbegin(v1), cend(v1), cbegin(v2), cend(v2),
                [](m2::PointD const & p1, m2::PointD const & p2) { return IsEqual(p1, p2); });
 }
+
+template <class Sink, class T>
+void WritePOD(Sink & sink, T const & value)
+{
+  static_assert(std::is_trivially_copyable<T>::value, "");
+
+  sink.Write(&value, sizeof(T));
+}
+
+template <class Sink, class T>
+void ReadPOD(Sink & src, T & value)
+{
+  static_assert(std::is_trivially_copyable<T>::value, "");
+
+  src.Read(&value, sizeof(T));
+}
 }  // namespace
 
 namespace feature
@@ -337,6 +355,16 @@ bool FeatureBuilder::operator==(FeatureBuilder const & fb) const
   return true;
 }
 
+bool FeatureBuilder::IsExactEq(FeatureBuilder const & fb) const
+{
+  return m_center == fb.m_center &&
+      m_polygons == fb.m_polygons &&
+      m_limitRect == fb.m_limitRect &&
+      m_osmIds == fb.m_osmIds &&
+      m_params == fb.m_params &&
+      m_coastCell == fb.m_coastCell;
+}
+
 void FeatureBuilder::SerializeBase(Buffer & data, serial::GeometryCodingParams const & params,
                                    bool saveAddInfo) const
 {
@@ -370,10 +398,10 @@ void FeatureBuilder::SerializeForIntermediate(Buffer & data) const
     WriteVarInt(sink, m_coastCell);
   }
 
-  // save OSM IDs to link meta information with sorted features later
+  // Save OSM IDs to link meta information with sorted features later.
   rw::WriteVectorOfPOD(sink, m_osmIds);
 
-  // check for correct serialization
+  // Check for correct serialization.
 #ifdef DEBUG
   Buffer tmp(data);
   FeatureBuilder fb;
@@ -383,7 +411,7 @@ void FeatureBuilder::SerializeForIntermediate(Buffer & data) const
 }
 
 void FeatureBuilder::SerializeBorderForIntermediate(serial::GeometryCodingParams const & params,
-                                              Buffer & data) const
+                                                    Buffer & data) const
 {
   data.clear();
 
@@ -427,7 +455,7 @@ void FeatureBuilder::DeserializeFromIntermediate(Buffer & data)
   {
     m_polygons.clear();
     uint32_t const count = ReadVarUint<uint32_t>(source);
-    ASSERT_GREATER ( count, 0, (*this) );
+    ASSERT_GREATER( count, 0, (*this) );
 
     for (uint32_t i = 0; i < count; ++i)
     {
@@ -452,7 +480,7 @@ void FeatureBuilder::SerializeAccuratelyForIntermediate(Buffer & data) const
   m_params.Write(sink, true /* store additional info from FeatureParams */);
   if (IsPoint())
   {
-    rw::WritePOD(sink, m_center);
+    WritePOD(sink, m_center);
   }
   else
   {
@@ -463,9 +491,9 @@ void FeatureBuilder::SerializeAccuratelyForIntermediate(Buffer & data) const
     WriteVarInt(sink, m_coastCell);
   }
 
-  // save OSM IDs to link meta information with sorted features later
+  // Save OSM IDs to link meta information with sorted features later.
   rw::WriteVectorOfPOD(sink, m_osmIds);
-  // check for correct serialization
+  // Check for correct serialization.
 #ifdef DEBUG
   Buffer tmp(data);
   FeatureBuilder fb;
@@ -482,14 +510,14 @@ void FeatureBuilder::DeserializeAccuratelyFromIntermediate(Buffer & data)
   m_limitRect.MakeEmpty();
   if (IsPoint())
   {
-    rw::ReadPOD(source, m_center);
+    ReadPOD(source, m_center);
     m_limitRect.Add(m_center);
   }
   else
   {
     m_polygons.clear();
     uint32_t const count = ReadVarUint<uint32_t>(source);
-    ASSERT_GREATER (count, 0, (*this));
+    ASSERT_GREATER(count, 0, (*this));
     for (uint32_t i = 0; i < count; ++i)
     {
       m_polygons.push_back(PointSeq());
diff --git a/generator/feature_builder.hpp b/generator/feature_builder.hpp
index f9b47a6143..a340692509 100644
--- a/generator/feature_builder.hpp
+++ b/generator/feature_builder.hpp
@@ -44,7 +44,11 @@ public:
   };
 
   FeatureBuilder();
-  bool operator==(FeatureBuilder const &) const;
+  // Checks for equality. The error of coordinates is allowed.
+  bool operator==(FeatureBuilder const & fb) const;
+  // Checks for equality. The error of coordinates isn't allowed. Binary equality check of
+  // coordinates is used.
+  bool IsExactEq(FeatureBuilder const & fb) const;
 
   // To work with geometry.
   void AddPoint(m2::PointD const & p);
@@ -135,12 +139,6 @@ public:
     return m_params.m_types.empty();
   }
 
-  template <class FnT>
-  bool HasTypesIf(FnT fn) const
-  {
-    return std::any_of(std::begin(m_params.m_types), std::end(m_params.m_types), fn);
-  }
-
   bool HasType(uint32_t t) const { return m_params.IsTypeExist(t); }
   bool HasType(uint32_t t, uint8_t level) const { return m_params.IsTypeExist(t, level); }
   uint32_t FindType(uint32_t comp, uint8_t level) const { return m_params.FindType(comp, level); }
@@ -245,12 +243,12 @@ protected:
 void Check(FeatureBuilder const fb);
 std::string DebugPrint(FeatureBuilder const & fb);
 
-// SerializePolicy serialization and deserialization.
+// SerializationPolicy serialization and deserialization.
 namespace serialization_policy
 {
 enum class SerializationVersion : uint32_t
 {
-  Undef,
+  Undefined,
   MinSize,
   MaxAccuracy
 };
@@ -291,13 +289,13 @@ struct MaxAccuracy
 // TODO(maksimandrianov): I would like to support the verification of serialization versions,
 // but this requires reworking of FeatureCollector class and its derived classes. It is in future plans
 
-//template <class SerializePolicy, class Source>
+//template <class SerializationPolicy, class Source>
 //void TryReadAndCheckVersion(Source & src)
 //{
 //  if (src.Size() - src.Pos() >= sizeof(serialization_policy::TypeSerializationVersion))
 //  {
 //    auto const type = ReadVarUint<serialization_policy::TypeSerializationVersion>(src);
-//    CHECK_EQUAL(type, SerializePolicy::kSerializationVersion, ());
+//    CHECK_EQUAL(type, SerializationPolicy::kSerializationVersion, ());
 //  }
 //  else
 //  {
@@ -306,36 +304,36 @@ struct MaxAccuracy
 //}
 
 // Read feature from feature source.
-template <class SerializePolicy = serialization_policy::MinSize, class Source>
+template <class SerializationPolicy = serialization_policy::MinSize, class Source>
 void ReadFromSourceRawFormat(Source & src, FeatureBuilder & fb)
 {
   uint32_t const sz = ReadVarUint<uint32_t>(src);
   typename FeatureBuilder::Buffer buffer(sz);
   src.Read(&buffer[0], sz);
-  SerializePolicy::Deserialize(fb, buffer);
+  SerializationPolicy::Deserialize(fb, buffer);
 }
 
 // Process features in .dat file.
-template <class SerializePolicy = serialization_policy::MinSize, class ToDo>
+template <class SerializationPolicy = serialization_policy::MinSize, class ToDo>
 void ForEachFromDatRawFormat(std::string const & filename, ToDo && toDo)
 {
   FileReader reader(filename);
   ReaderSource<FileReader> src(reader);
-//  TryReadAndCheckVersion<SerializePolicy>(src);
+  // TryReadAndCheckVersion<SerializationPolicy>(src);
   auto const fileSize = reader.Size();
-  uint64_t currPos = src.Pos();
+  auto currPos = src.Pos();
   // read features one by one
   while (currPos < fileSize)
   {
     FeatureBuilder fb;
-    ReadFromSourceRawFormat<SerializePolicy>(src, fb);
+    ReadFromSourceRawFormat<SerializationPolicy>(src, fb);
     toDo(fb, currPos);
     currPos = src.Pos();
   }
 }
 
 /// Parallel process features in .dat file.
-template <class SerializePolicy = serialization_policy::MinSize, class ToDo>
+template <class SerializationPolicy = serialization_policy::MinSize, class ToDo>
 void ForEachParallelFromDatRawFormat(size_t threadsCount, std::string const & filename,
                                      ToDo && toDo)
 {
@@ -345,9 +343,9 @@ void ForEachParallelFromDatRawFormat(size_t threadsCount, std::string const & fi
 
   FileReader reader(filename);
   ReaderSource<FileReader> src(reader);
-//  TryReadAndCheckVersion<SerializePolicy>(src);
+//  TryReadAndCheckVersion<SerializationPolicy>(src);
   auto const fileSize = reader.Size();
-  uint64_t currPos = src.Pos();
+  auto currPos = src.Pos();
   std::mutex readMutex;
   auto concurrentProcessor = [&] {
     for (;;)
@@ -361,7 +359,7 @@ void ForEachParallelFromDatRawFormat(size_t threadsCount, std::string const & fi
         if (fileSize <= currPos)
           break;
 
-        ReadFromSourceRawFormat<SerializePolicy>(src, fb);
+        ReadFromSourceRawFormat<SerializationPolicy>(src, fb);
         featurePos = currPos;
         currPos = src.Pos();
       }
@@ -374,30 +372,33 @@ void ForEachParallelFromDatRawFormat(size_t threadsCount, std::string const & fi
   for (size_t i = 0; i < threadsCount; ++i)
     threadPool.Submit(concurrentProcessor);
 }
-template <class SerializePolicy = serialization_policy::MinSize>
+template <class SerializationPolicy = serialization_policy::MinSize>
 std::vector<FeatureBuilder> ReadAllDatRawFormat(std::string const & fileName)
 {
   std::vector<FeatureBuilder> fbs;
-  ForEachFromDatRawFormat<SerializePolicy>(fileName, [&](auto && fb, auto const &) {
+  ForEachFromDatRawFormat<SerializationPolicy>(fileName, [&](auto && fb, auto const &) {
     fbs.emplace_back(std::move(fb));
   });
   return fbs;
 }
 
-template <class SerializePolicy = serialization_policy::MinSize, class Writer = FileWriter>
+template <class SerializationPolicy = serialization_policy::MinSize, class Writer = FileWriter>
 class FeatureBuilderWriter
 {
 public:
-  FeatureBuilderWriter(std::string const & filename, FileWriter::Op op = FileWriter::Op::OP_WRITE_TRUNCATE)
+  explicit FeatureBuilderWriter(std::string const & filename,
+                                FileWriter::Op op = FileWriter::Op::OP_WRITE_TRUNCATE)
     : m_writer(filename, op)
   {
-//    WriteVarUint(m_writer, static_cast<serialization_policy::TypeSerializationVersion>(SerializePolicy::kSerializationVersion));
+    // TODO(maksimandrianov): I would like to support the verification of serialization versions,
+    // but this requires reworking of FeatureCollector class and its derived classes. It is in future plans
+    // WriteVarUint(m_writer, static_cast<serialization_policy::TypeSerializationVersion>(SerializationPolicy::kSerializationVersion));
   }
 
   void Write(FeatureBuilder const & fb)
   {
     FeatureBuilder::Buffer buffer;
-    SerializePolicy::Serialize(fb, buffer);
+    SerializationPolicy::Serialize(fb, buffer);
     WriteVarUint(m_writer, static_cast<uint32_t>(buffer.size()));
     m_writer.Write(buffer.data(), buffer.size() * sizeof(FeatureBuilder::Buffer::value_type));
   }
diff --git a/generator/generator_tests/feature_builder_test.cpp b/generator/generator_tests/feature_builder_test.cpp
index f661fbc5d2..4f230fdae9 100644
--- a/generator/generator_tests/feature_builder_test.cpp
+++ b/generator/generator_tests/feature_builder_test.cpp
@@ -125,7 +125,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_Waterfall)
 
   Check(fb2);
   TEST_EQUAL(fb1, fb2, ());
-  TEST_EQUAL(fb2.GetTypesCount(), 1, ());
+  TEST_EQUAL(fb2.GetTypesCount(), 1, ());;
 }
 
 UNIT_CLASS_TEST(TestWithClassificator, FBbuilder_GetMostGeneralOsmId)
@@ -271,3 +271,40 @@ UNIT_CLASS_TEST(TestWithClassificator, FeatureBuilder12_SerializeLocalityObjectF
     TEST(base::AlmostEqualAbs(point, m2::PointD(10.1, 15.8), 1e-7), ());
   });
 }
+
+UNIT_TEST(FeatureBuilder_SerializeAccuratelyForIntermediate)
+{
+  FeatureBuilder fb1;
+  FeatureParams params;
+
+  char const * arr2[][2] = {
+    { "railway", "rail" },
+    { "highway", "motorway" },
+    { "hwtag", "oneway" },
+    { "psurface", "paved_good" },
+    { "junction", "roundabout" },
+  };
+
+  AddTypes(params, arr2);
+  params.FinishAddingTypes();
+  fb1.SetParams(params);
+
+  auto const diff = 0.33333333334567;
+  for (size_t i = 0; i < 100; ++i)
+      fb1.AddPoint(m2::PointD(i + diff, i + 1 + diff));
+
+  fb1.SetLinear();
+
+  TEST(fb1.RemoveInvalidTypes(), ());
+  Check(fb1);
+
+  FeatureBuilder::Buffer buffer;
+  TEST(fb1.PreSerializeAndRemoveUselessNamesForIntermediate(), ());
+  fb1.SerializeAccuratelyForIntermediate(buffer);
+
+  FeatureBuilder fb2;
+  fb2.DeserializeAccuratelyFromIntermediate(buffer);
+
+  Check(fb2);
+  TEST(fb1.IsExactEq(fb2), ());
+}
diff --git a/generator/processor_booking.hpp b/generator/processor_booking.hpp
index 75acadbde0..091c3aecc4 100644
--- a/generator/processor_booking.hpp
+++ b/generator/processor_booking.hpp
@@ -1,16 +1,16 @@
 #pragma once
 
-#include "generator/processor_interface.hpp"
 #include "generator/feature_builder.hpp"
 #include "generator/feature_generator.hpp"
+#include "generator/processor_interface.hpp"
 
 #include "indexer/feature_data.hpp"
 
 #include "base/assert.hpp"
 #include "base/geo_object_id.hpp"
-#include "base/logging.hpp"
 
 #include <map>
+#include <memory>
 
 namespace generator
 {
@@ -20,16 +20,16 @@ template <typename Dataset>
 class ProcessorBooking : public FeatureProcessorInterface
 {
 public:
-  ProcessorBooking(Dataset const & dataset, map<base::GeoObjectId, feature::FeatureBuilder> & features)
+  ProcessorBooking(Dataset const & dataset, std::map<base::GeoObjectId, feature::FeatureBuilder> & features)
     : m_dataset(dataset), m_features(features) {}
 
   // FeatureProcessorInterface overrides:
   virtual std::shared_ptr<FeatureProcessorInterface> Clone() const
   {
     CHECK(false, ());
+    return {};
   }
 
-
   void Process(feature::FeatureBuilder & fb) override
   {
     if (m_dataset.NecessaryMatchingConditionHolds(fb))
@@ -38,12 +38,6 @@ public:
 
   void Flush() override {}
 
-  bool Finish() override
-  {
-    LOG_SHORT(LINFO, ("Num of booking elements:", m_features.size()));
-    return true;
-  }
-
   void Merge(FeatureProcessorInterface const &) override
   {
     CHECK(false, ());
@@ -51,6 +45,6 @@ public:
 
 private:
   Dataset const & m_dataset;
-  map<base::GeoObjectId, feature::FeatureBuilder> & m_features;
+  std::map<base::GeoObjectId, feature::FeatureBuilder> & m_features;
 };
 }  // namespace generator
diff --git a/generator/processor_coastline.cpp b/generator/processor_coastline.cpp
index c25fb55aa5..0ffdca64de 100644
--- a/generator/processor_coastline.cpp
+++ b/generator/processor_coastline.cpp
@@ -19,7 +19,7 @@ ProcessorCoastline::ProcessorCoastline(std::shared_ptr<FeatureProcessorQueue> co
 {
   m_processingChain = std::make_shared<RepresentationCoastlineLayer>();
   m_processingChain->Add(std::make_shared<PrepareCoastlineFeatureLayer>());
-  auto affilation = std::make_shared<feature::OneFileAffiliation>(WORLD_COASTS_FILE_NAME);
+  auto affilation = std::make_shared<feature::SingleAffiliation>(WORLD_COASTS_FILE_NAME);
   m_affilationsLayer = std::make_shared<AffilationsFeatureLayer<>>(kAffilationsBufferSize, affilation);
   m_processingChain->Add(m_affilationsLayer);
 }
@@ -40,11 +40,6 @@ void ProcessorCoastline::Flush()
   m_affilationsLayer->AddBufferToQueue(m_queue);
 }
 
-bool ProcessorCoastline::Finish()
-{
-  return true;
-}
-
 void ProcessorCoastline::Merge(FeatureProcessorInterface const & other)
 {
   other.MergeInto(*this);
diff --git a/generator/processor_coastline.hpp b/generator/processor_coastline.hpp
index 6f5423ffee..d13eed9ef9 100644
--- a/generator/processor_coastline.hpp
+++ b/generator/processor_coastline.hpp
@@ -5,23 +5,20 @@
 #include "generator/processor_interface.hpp"
 
 #include <memory>
-#include <string>
-#include <vector>
 
 namespace generator
 {
-// This class is implementation oft FeatureProcessorInterface for coastlines.
+// This class is implementation of the FeatureProcessorInterface for coastlines.
 class ProcessorCoastline : public FeatureProcessorInterface
 {
 public:
   explicit ProcessorCoastline(std::shared_ptr<FeatureProcessorQueue> const & queue);
 
-  // EmitterInterface overrides:
+  // FeatureProcessorInterface overrides:
   std::shared_ptr<FeatureProcessorInterface> Clone() const override;
 
   void Process(feature::FeatureBuilder & feature) override;
   void Flush() override;
-  bool Finish() override;
 
   void Merge(FeatureProcessorInterface const & other) override;
   void MergeInto(ProcessorCoastline & other) const override;
diff --git a/generator/processor_country.cpp b/generator/processor_country.cpp
index a0c00dbd13..476e8b1c46 100644
--- a/generator/processor_country.cpp
+++ b/generator/processor_country.cpp
@@ -7,22 +7,20 @@
 
 #include <fstream>
 
-#include "defines.hpp"
-
 namespace generator
 {
 ProcessorCountry::ProcessorCountry(std::shared_ptr<FeatureProcessorQueue> const & queue,
                                    std::string const & bordersPath, std::string const & layerLogFilename,
-                                   bool isMwmsForWholeWorld)
+                                   bool haveBordersForWholeWorld)
   : m_bordersPath(bordersPath)
   , m_layerLogFilename(layerLogFilename)
   , m_queue(queue)
-  , m_isMwmsForWholeWorld(isMwmsForWholeWorld)
+  , m_haveBordersForWholeWorld(haveBordersForWholeWorld)
 {
   m_processingChain = std::make_shared<RepresentationLayer>();
   m_processingChain->Add(std::make_shared<PrepareFeatureLayer>());
   m_processingChain->Add(std::make_shared<CountryLayer>());
-  auto affilation = std::make_shared<feature::CountriesFilesAffiliation>(bordersPath, isMwmsForWholeWorld);
+  auto affilation = std::make_shared<feature::CountriesFilesAffiliation>(bordersPath, haveBordersForWholeWorld);
   m_affilationsLayer = std::make_shared<AffilationsFeatureLayer<>>(kAffilationsBufferSize, affilation);
   m_processingChain->Add(m_affilationsLayer);
 }
@@ -30,7 +28,7 @@ ProcessorCountry::ProcessorCountry(std::shared_ptr<FeatureProcessorQueue> const
 
 std::shared_ptr<FeatureProcessorInterface> ProcessorCountry::Clone() const
 {
-  return std::make_shared<ProcessorCountry>(m_queue, m_bordersPath, m_layerLogFilename, m_isMwmsForWholeWorld);
+  return std::make_shared<ProcessorCountry>(m_queue, m_bordersPath, m_layerLogFilename, m_haveBordersForWholeWorld);
 }
 
 void ProcessorCountry::Process(feature::FeatureBuilder & feature)
@@ -44,12 +42,6 @@ void ProcessorCountry::Flush()
   m_affilationsLayer->AddBufferToQueue(m_queue);
 }
 
-bool ProcessorCountry::Finish()
-{
-  //  WriteDump();
-  return true;
-}
-
 void ProcessorCountry::WriteDump()
 {
   std::ofstream file;
diff --git a/generator/processor_country.hpp b/generator/processor_country.hpp
index 1e93529044..9481668771 100644
--- a/generator/processor_country.hpp
+++ b/generator/processor_country.hpp
@@ -21,14 +21,13 @@ class ProcessorCountry : public FeatureProcessorInterface
 public:
   explicit ProcessorCountry(std::shared_ptr<FeatureProcessorQueue> const & queue,
                             std::string const & bordersPath, std::string const & layerLogFilename,
-                            bool isMwmsForWholeWorld);
+                            bool haveBordersForWholeWorld);
 
   // FeatureProcessorInterface overrides:
   std::shared_ptr<FeatureProcessorInterface> Clone() const override;
 
   void Process(feature::FeatureBuilder & feature) override;
   void Flush() override;
-  bool Finish() override;
 
   void Merge(FeatureProcessorInterface const & other) override;
   void MergeInto(ProcessorCountry & other) const override;
@@ -40,7 +39,7 @@ private:
   std::string m_layerLogFilename;
   std::shared_ptr<AffilationsFeatureLayer<>> m_affilationsLayer;
   std::shared_ptr<FeatureProcessorQueue> m_queue;
-  bool m_isMwmsForWholeWorld;
   std::shared_ptr<LayerBase> m_processingChain;
+  bool m_haveBordersForWholeWorld;
 };
 }  // namespace generator
diff --git a/generator/processor_factory.hpp b/generator/processor_factory.hpp
index 5983b43845..e48a378b96 100644
--- a/generator/processor_factory.hpp
+++ b/generator/processor_factory.hpp
@@ -1,14 +1,13 @@
 #pragma once
 
+#include "generator/factory_utils.hpp"
 #include "generator/processor_booking.hpp"
 #include "generator/processor_coastline.hpp"
 #include "generator/processor_country.hpp"
 #include "generator/processor_interface.hpp"
 #include "generator/processor_noop.hpp"
-#include "generator/processor_restaurants.hpp"
 #include "generator/processor_simple.hpp"
 #include "generator/processor_world.hpp"
-#include "generator/factory_utils.hpp"
 
 #include "base/assert.hpp"
 
@@ -19,7 +18,6 @@ namespace generator
 {
 enum class ProcessorType
 {
-  Restaurants,
   Simple,
   Country,
   Coastline,
@@ -39,8 +37,6 @@ std::shared_ptr<FeatureProcessorInterface> CreateProcessor(ProcessorType type, A
     return create<ProcessorCountry>(std::forward<Args>(args)...);
   case ProcessorType::Simple:
     return create<ProcessorSimple>(std::forward<Args>(args)...);
-  case ProcessorType::Restaurants:
-    return create<ProcessorRestaurants>(std::forward<Args>(args)...);
   case ProcessorType::World:
     return create<ProcessorWorld>(std::forward<Args>(args)...);
   case ProcessorType::Noop:
diff --git a/generator/processor_interface.hpp b/generator/processor_interface.hpp
index 79609c4513..e0eae37ba0 100644
--- a/generator/processor_interface.hpp
+++ b/generator/processor_interface.hpp
@@ -16,7 +16,6 @@ namespace generator
 class ProcessorCoastline;
 class ProcessorCountry;
 class ProcessorNoop;
-class ProcessorRestaurants;
 class ProcessorSimple;
 class ProcessorWorld;
 
@@ -31,16 +30,12 @@ public:
   // This method is used by OsmTranslator to pass |fb| to Processor for further processing.
   virtual void Process(feature::FeatureBuilder & fb) = 0;
   virtual void Flush() = 0;
-  // Finish is used in GenerateFeatureImpl to make whatever work is needed after all OsmElements
-  // are processed.
-  virtual bool Finish() = 0;
 
   virtual void Merge(FeatureProcessorInterface const &) = 0;
 
   virtual void MergeInto(ProcessorCoastline &) const { FailIfMethodUnsupported(); }
   virtual void MergeInto(ProcessorCountry &) const { FailIfMethodUnsupported(); }
   virtual void MergeInto(ProcessorNoop &) const { FailIfMethodUnsupported(); }
-  virtual void MergeInto(ProcessorRestaurants &) const { FailIfMethodUnsupported(); }
   virtual void MergeInto(ProcessorSimple &) const { FailIfMethodUnsupported(); }
   virtual void MergeInto(ProcessorWorld &) const { FailIfMethodUnsupported(); }
 
diff --git a/generator/processor_noop.hpp b/generator/processor_noop.hpp
index c90d3a809c..2660613477 100644
--- a/generator/processor_noop.hpp
+++ b/generator/processor_noop.hpp
@@ -4,8 +4,6 @@
 #include "generator/processor_interface.hpp"
 
 #include <memory>
-#include <string>
-#include <vector>
 
 class FeatureParams;
 
@@ -22,8 +20,6 @@ public:
 
   void Process(feature::FeatureBuilder &) override {}
   void Flush() override {}
-  bool Finish() override { return true; }
-
 
   void Merge(FeatureProcessorInterface const &) override {}
   void MergeInto(ProcessorNoop &) const override {}
diff --git a/generator/processor_restaurants.cpp b/generator/processor_restaurants.cpp
deleted file mode 100644
index 6fc89f9a0b..0000000000
--- a/generator/processor_restaurants.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "generator/processor_restaurants.hpp"
-
-#include "generator/feature_builder.hpp"
-
-#include "indexer/ftypes_matcher.hpp"
-
-namespace generator
-{
-ProcessorRestaurants::ProcessorRestaurants(std::shared_ptr<FeatureProcessorQueue> const & queue)
-  : m_queue(queue)
-{
-  auto affilation = std::make_shared<feature::OneFileAffiliation>("");
-  m_affilationsLayer = std::make_shared<AffilationsFeatureLayer<>>(kAffilationsBufferSize, affilation);
-  m_processingChain->Add(m_affilationsLayer);
-}
-
-std::shared_ptr<FeatureProcessorInterface> ProcessorRestaurants::Clone() const
-{
-  return std::make_shared<ProcessorRestaurants>(m_queue);
-}
-
-void ProcessorRestaurants::Process(feature::FeatureBuilder & fb)
-{
-  if (!ftypes::IsEatChecker::Instance()(fb.GetParams().m_types) || fb.GetParams().name.IsEmpty())
-  {
-    ++m_stats.m_unexpectedFeatures;
-    return;
-  }
-
-  switch (fb.GetGeomType())
-  {
-  case feature::GeomType::Point: ++m_stats.m_restaurantsPoi; break;
-  case feature::GeomType::Area: ++m_stats.m_restaurantsBuilding; break;
-  default: ++m_stats.m_unexpectedFeatures;
-  }
-
-  m_processingChain->Handle(fb);
-  m_affilationsLayer->AddBufferToQueueIfFull(m_queue);
-}
-
-void ProcessorRestaurants::Flush()
-{
-  m_affilationsLayer->AddBufferToQueue(m_queue);
-}
-
-bool ProcessorRestaurants::Finish()
-{
-  LOG_SHORT(LINFO, ("Number of restaurants: POI:", m_stats.m_restaurantsPoi,
-                    "BUILDING:", m_stats.m_restaurantsBuilding,
-                    "INVALID:", m_stats.m_unexpectedFeatures));
-  return true;
-}
-
-void ProcessorRestaurants::Merge(FeatureProcessorInterface const & other)
-{
-  other.MergeInto(*this);
-}
-
-void ProcessorRestaurants::MergeInto(ProcessorRestaurants & other) const
-{
-  other.m_processingChain->Merge(m_processingChain);
-  other.m_stats = other.m_stats + m_stats;
-}
-}  // namespace generator
diff --git a/generator/processor_restaurants.hpp b/generator/processor_restaurants.hpp
deleted file mode 100644
index af6894fa59..0000000000
--- a/generator/processor_restaurants.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "generator/processor_interface.hpp"
-#include "generator/feature_builder.hpp"
-#include "generator/feature_processing_layers.hpp"
-
-#include <vector>
-#include <string>
-
-namespace generator
-{
-class ProcessorRestaurants : public FeatureProcessorInterface
-{
-public:
-  explicit ProcessorRestaurants(std::shared_ptr<FeatureProcessorQueue> const & queue);
-
-  // FeatureProcessorInterface overrides:
-  std::shared_ptr<FeatureProcessorInterface> Clone() const override;
-
-  void Process(feature::FeatureBuilder & fb) override;
-  void Flush() override;
-  bool Finish() override;
-
-  void Merge(FeatureProcessorInterface const & other) override;
-  void MergeInto(ProcessorRestaurants & other) const override;
-
-private:
-  struct Stats
-  {
-    Stats operator+(Stats const & other) const
-    {
-      Stats s;
-      s.m_restaurantsPoi = m_restaurantsPoi  + other.m_restaurantsPoi;
-      s.m_restaurantsBuilding = m_restaurantsBuilding  + other.m_restaurantsBuilding;
-      s.m_unexpectedFeatures = m_unexpectedFeatures  + other.m_unexpectedFeatures;
-      return s;
-    }
-
-    // Number of features of any "food type".
-    uint32_t m_restaurantsPoi = 0;
-    uint32_t m_restaurantsBuilding = 0;
-    uint32_t m_unexpectedFeatures = 0;
-  };
-
-  std::shared_ptr<AffilationsFeatureLayer<>> m_affilationsLayer;
-  std::shared_ptr<FeatureProcessorQueue> m_queue;
-  std::shared_ptr<LayerBase> m_processingChain;
-  Stats m_stats;
-};
-}  // namespace generator
diff --git a/generator/processor_simple.cpp b/generator/processor_simple.cpp
index 33df2892c7..17ff0089b4 100644
--- a/generator/processor_simple.cpp
+++ b/generator/processor_simple.cpp
@@ -8,19 +8,19 @@
 namespace generator
 {
 ProcessorSimple::ProcessorSimple(std::shared_ptr<FeatureProcessorQueue> const & queue,
-                                 std::string const & filename)
-  : m_filename(filename)
+                                 std::string const & name)
+  : m_name(name)
   , m_queue(queue)
 {
   m_processingChain->Add(std::make_shared<PreserializeLayer>());
-  auto affilation = std::make_shared<feature::OneFileAffiliation>(filename);
+  auto affilation = std::make_shared<feature::SingleAffiliation>(name);
   m_affilationsLayer = std::make_shared<AffilationsFeatureLayer<feature::serialization_policy::MinSize>>(kAffilationsBufferSize, affilation);
   m_processingChain->Add(m_affilationsLayer);
 }
 
 std::shared_ptr<FeatureProcessorInterface>ProcessorSimple::Clone() const
 {
-  return std::make_shared<ProcessorSimple>(m_queue, m_filename);
+  return std::make_shared<ProcessorSimple>(m_queue, m_name);
 }
 
 void ProcessorSimple::Process(feature::FeatureBuilder & fb)
@@ -34,11 +34,6 @@ void ProcessorSimple::Flush()
   m_affilationsLayer->AddBufferToQueue(m_queue);
 }
 
-bool ProcessorSimple::Finish()
-{
-  return true;
-}
-
 void ProcessorSimple::Merge(FeatureProcessorInterface const & other)
 {
   other.MergeInto(*this);
diff --git a/generator/processor_simple.hpp b/generator/processor_simple.hpp
index 5d1d389326..e8b92983ad 100644
--- a/generator/processor_simple.hpp
+++ b/generator/processor_simple.hpp
@@ -6,31 +6,30 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
 namespace generator
 {
-// ProcessorSimpleWriter class is a simple emitter. It does not filter objects.
+// ProcessorSimple class is a simple processor. It does not filter objects.
 class ProcessorSimple : public FeatureProcessorInterface
 {
 public:
+  // |name| is bucket name. For example it may be "World", "geo_objects", "regions" etc.
   explicit ProcessorSimple(std::shared_ptr<FeatureProcessorQueue> const & queue,
-                           std::string const & filename);
+                           std::string const & name);
 
-  // EmitterInterface overrides:
+  // FeatureProcessorInterface overrides:
   std::shared_ptr<FeatureProcessorInterface> Clone() const override;
 
   void Process(feature::FeatureBuilder & fb) override;
   void Flush() override;
-  bool Finish() override;
 
   void Merge(FeatureProcessorInterface const & other) override;
   void MergeInto(ProcessorSimple & other) const override;
 
-  std::string GetFilename() const { return m_filename; }
+  std::string GetFilename() const { return m_name; }
 
 private:
-  std::string m_filename;
+  std::string m_name;
   std::shared_ptr<AffilationsFeatureLayer<feature::serialization_policy::MinSize>> m_affilationsLayer;
   std::shared_ptr<FeatureProcessorQueue> m_queue;
   std::shared_ptr<LayerBase> m_processingChain;
diff --git a/generator/processor_world.cpp b/generator/processor_world.cpp
index 0e72d2bb89..54b4059139 100644
--- a/generator/processor_world.cpp
+++ b/generator/processor_world.cpp
@@ -16,14 +16,14 @@ ProcessorWorld::ProcessorWorld(std::shared_ptr<FeatureProcessorQueue> const & qu
   m_processingChain = std::make_shared<RepresentationLayer>();
   m_processingChain->Add(std::make_shared<PrepareFeatureLayer>());
   m_processingChain->Add(std::make_shared<WorldLayer>(popularityFilename));
-  auto affilation = std::make_shared<feature::OneFileAffiliation>(WORLD_FILE_NAME);
+  auto affilation = std::make_shared<feature::SingleAffiliation>(WORLD_FILE_NAME);
   m_affilationsLayer = std::make_shared<AffilationsFeatureLayer<>>(kAffilationsBufferSize, affilation);
   m_processingChain->Add(m_affilationsLayer);
 }
 
 std::shared_ptr<FeatureProcessorInterface> ProcessorWorld::Clone() const
 {
-   return std::make_shared<ProcessorWorld>(m_queue, m_popularityFilename);
+  return std::make_shared<ProcessorWorld>(m_queue, m_popularityFilename);
 }
 
 void ProcessorWorld::Process(feature::FeatureBuilder & feature)
@@ -37,11 +37,6 @@ void ProcessorWorld::Flush()
   m_affilationsLayer->AddBufferToQueue(m_queue);
 }
 
-bool ProcessorWorld::Finish()
-{
-  return true;
-}
-
 void ProcessorWorld::Merge(FeatureProcessorInterface const & other)
 {
   other.MergeInto(*this);
diff --git a/generator/processor_world.hpp b/generator/processor_world.hpp
index 3e43559283..f1ee0eeb3a 100644
--- a/generator/processor_world.hpp
+++ b/generator/processor_world.hpp
@@ -7,7 +7,6 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
 namespace feature
 {
@@ -16,19 +15,18 @@ struct GenerateInfo;
 
 namespace generator
 {
-// This class is implementation of EmitterInterface for the world.
+// This class is implementation of FeatureProcessorInterface for the world.
 class ProcessorWorld : public FeatureProcessorInterface
 {
 public:
   explicit ProcessorWorld(std::shared_ptr<FeatureProcessorQueue> const & queue,
                           std::string const & popularityFilename);
 
-  // EmitterInterface overrides:
+  // FeatureProcessorInterface overrides:
   std::shared_ptr<FeatureProcessorInterface> Clone() const override;
 
   void Process(feature::FeatureBuilder & feature) override;
   void Flush() override;
-  bool Finish() override;
 
   void Merge(FeatureProcessorInterface const & other) override;
   void MergeInto(ProcessorWorld & other) const override;