diff --git a/coding/string_utf8_multilang.cpp b/coding/string_utf8_multilang.cpp
index 355603236c..734b7d380c 100644
--- a/coding/string_utf8_multilang.cpp
+++ b/coding/string_utf8_multilang.cpp
@@ -259,6 +259,15 @@ int8_t StringUtf8Multilang::FindString(string const & utf8s) const
   return result;
 }
 
+size_t StringUtf8Multilang::CountLangs() const
+{
+  size_t count = 0;
+  for (size_t i = 0; i < m_s.size(); i = GetNextIndex(i))
+    ++count;
+
+  return count;
+}
+
 string DebugPrint(StringUtf8Multilang const & s)
 {
   string result;
diff --git a/coding/string_utf8_multilang.hpp b/coding/string_utf8_multilang.hpp
index 7b6d5cd919..105d52c6a5 100644
--- a/coding/string_utf8_multilang.hpp
+++ b/coding/string_utf8_multilang.hpp
@@ -142,6 +142,7 @@ public:
   bool HasString(int8_t lang) const;
 
   int8_t FindString(string const & utf8s) const;
+  size_t CountLangs() const;
 
   template <class TSink>
   void Write(TSink & sink) const
diff --git a/generator/CMakeLists.txt b/generator/CMakeLists.txt
index ddb25f717e..858ca4bb17 100644
--- a/generator/CMakeLists.txt
+++ b/generator/CMakeLists.txt
@@ -121,10 +121,14 @@ set(SRC
   regions/region.hpp
   regions/region_base.cpp
   regions/region_base.hpp
+  regions/region_info.cpp
+  regions/region_info.hpp
   regions/regions.cpp
   regions/regions.hpp
   regions/regions_builder.cpp
   regions/regions_builder.hpp
+  regions/regions_fixer.cpp
+  regions/regions_fixer.hpp
   regions/to_string_policy.cpp
   regions/to_string_policy.hpp
   restriction_collector.cpp
diff --git a/generator/generator_tests/region_info_collector_tests.cpp b/generator/generator_tests/region_info_collector_tests.cpp
index c26f4b31df..e40c6f7625 100644
--- a/generator/generator_tests/region_info_collector_tests.cpp
+++ b/generator/generator_tests/region_info_collector_tests.cpp
@@ -3,6 +3,7 @@
 #include "generator/generator_tests/common.hpp"
 #include "generator/osm_element.hpp"
 #include "generator/regions/collector_region_info.hpp"
+#include "generator/regions/region_info.hpp"
 
 #include "coding/file_name_utils.hpp"
 
diff --git a/generator/generator_tests/regions_tests.cpp b/generator/generator_tests/regions_tests.cpp
index 563e7384da..0784750ab6 100644
--- a/generator/generator_tests/regions_tests.cpp
+++ b/generator/generator_tests/regions_tests.cpp
@@ -149,20 +149,14 @@ RegionsBuilder::Regions MakeTestDataSet1(RegionInfo & collector)
 class Helper : public ToStringPolicyInterface
 {
 public:
-  Helper(std::vector<std::string> & bankOfNames) : m_bankOfNames(bankOfNames) {}
-
-  std::string ToString(Node::PtrList const & nodePtrList) override
+  std::string ToString(Node::PtrList const & nodePtrList) const override
   {
     std::stringstream stream;
     for (auto const & n : nodePtrList)
       stream << n->GetData().GetName();
 
-    auto str = stream.str();
-    m_bankOfNames.push_back(str);
-    return str;
+    return stream.str();
   }
-
-  std::vector<std::string> & m_bankOfNames;
 };
 
 bool ExistsName(std::vector<std::string> const & coll, std::string const name)
@@ -202,25 +196,20 @@ UNIT_TEST(RegionsBuilderTest_GetCountryTrees)
   auto const filename = MakeCollectorData();
   RegionInfo collector(filename);
   std::vector<std::string> bankOfNames;
-  RegionsBuilder builder(MakeTestDataSet1(collector), std::make_unique<Helper>(bankOfNames));
+  RegionsBuilder builder(MakeTestDataSet1(collector), std::make_unique<Helper>());
+  builder.ForEachNormalizedCountry([&](std::string const & name, Node::Ptr const & tree) {
+    auto const idStringList = builder.ToIdStringList(tree);
+    for (auto const & idString : idStringList)
+      bankOfNames.push_back(idString.second);
+  });
 
-  auto const countryTrees = builder.GetCountryTrees();
-  for (auto const & countryName : builder.GetCountryNames())
-  {
-    auto const keyRange = countryTrees.equal_range(countryName);
-    for (auto it = keyRange.first; it != keyRange.second; ++it)
-    {
-      auto const unused = builder.ToIdStringList(it->second);
-      UNUSED_VALUE(unused);
-    }
-  }
+  TEST(ExistsName(bankOfNames, "Country_2"), ());
+  TEST(ExistsName(bankOfNames, "Country_2_Region_8Country_2"), ());
 
-  TEST_EQUAL(std::count(std::begin(bankOfNames), std::end(bankOfNames), "Country_2"), 2, ());
   TEST(ExistsName(bankOfNames, "Country_1"), ());
   TEST(ExistsName(bankOfNames, "Country_1_Region_3Country_1"), ());
   TEST(ExistsName(bankOfNames, "Country_1_Region_4Country_1"), ());
   TEST(ExistsName(bankOfNames, "Country_1_Region_5Country_1"), ());
-  TEST(ExistsName(bankOfNames, "Country_2_Region_8Country_2"), ());
   TEST(ExistsName(bankOfNames, "Country_1_Region_5_Subregion_6Country_1_Region_5Country_1"), ());
   TEST(ExistsName(bankOfNames, "Country_1_Region_5_Subregion_7Country_1_Region_5Country_1"), ());
 }
diff --git a/generator/geo_objects/geo_objects.cpp b/generator/geo_objects/geo_objects.cpp
index 788cd4fd5e..800a42b6f7 100644
--- a/generator/geo_objects/geo_objects.cpp
+++ b/generator/geo_objects/geo_objects.cpp
@@ -11,6 +11,8 @@
 
 #include "coding/mmap_reader.hpp"
 
+#include "geometry/mercator.hpp"
+
 #include "base/geo_object_id.hpp"
 #include "base/logging.hpp"
 #include "base/timer.hpp"
@@ -32,6 +34,8 @@ namespace
 using KeyValue = std::pair<uint64_t, base::Json>;
 using IndexReader = ReaderPtr<Reader>;
 
+bool DefaultPred(KeyValue const &) { return true; }
+
 bool ParseKey(std::string const & line, int64_t & key)
 {
   auto const pos = line.find(" ");
@@ -97,8 +101,7 @@ public:
 class KeyValueMem : public KeyValueInterface
 {
 public:
-  KeyValueMem(std::istream & stream, std::function<bool(KeyValue const &)> pred =
-      [](KeyValue const &) { return true; })
+  KeyValueMem(std::istream & stream, std::function<bool(KeyValue const &)> pred = DefaultPred)
   {
     std::string line;
     KeyValue kv;
@@ -213,9 +216,8 @@ std::vector<base::GeoObjectId> SearchObjectsInIndex(FeatureBuilder1 const & fb,
 {
   std::vector<base::GeoObjectId> ids;
   auto const fn = [&ids] (base::GeoObjectId const & osmid) { ids.emplace_back(osmid); };
-  auto const center = fb.GetLimitRect().Center();
-  auto const rect = MercatorBounds::RectByCenterXYAndSizeInMeters(center, 0 /* meters */);
-  index.ForEachInRect(fn, rect);
+  auto const center = fb.GetKeyPoint();
+  index.ForEachInRect(fn, m2::RectD(center, center));
   return ids;
 }
 
@@ -227,10 +229,10 @@ int GetRankFromValue(base::Json json)
   return rank;
 }
 
-base::Json GetDeepestRegion(std::vector<base::GeoObjectId> const & ids,
-                            KeyValueInterface const & regionKv)
+boost::optional<KeyValue> GetDeepestRegion(std::vector<base::GeoObjectId> const & ids,
+                                           KeyValueInterface const & regionKv)
 {
-  base::Json deepest;
+  boost::optional<KeyValue> deepest;
   int deepestRank = 0;
   for (auto const & id : ids)
   {
@@ -249,17 +251,17 @@ base::Json GetDeepestRegion(std::vector<base::GeoObjectId> const & ids,
       continue;
     }
 
-    if (!deepest.get())
+    if (!deepest)
     {
       deepestRank = GetRankFromValue(temp);
-      deepest = temp;
+      deepest = KeyValue(static_cast<int64_t>(id.GetEncodedId()), temp);
     }
     else
     {
       int tempRank = GetRankFromValue(temp);
       if (deepestRank < tempRank)
       {
-        deepest = temp;
+        deepest = KeyValue(static_cast<int64_t>(id.GetEncodedId()), temp);
         deepestRank = tempRank;
       }
     }
@@ -274,17 +276,18 @@ void UpdateCoordinates(m2::PointD const & point, base::Json json)
   auto coordinates = json_object_get(geometry, "coordinates");
   if (json_array_size(coordinates) == 2)
   {
-    json_array_set_new(coordinates, 0, ToJSON(point.x).release());
-    json_array_set_new(coordinates, 1, ToJSON(point.y).release());
+    auto const latLon = MercatorBounds::ToLatLon(point);
+    json_array_set_new(coordinates, 0, ToJSON(latLon.lat).release());
+    json_array_set_new(coordinates, 1, ToJSON(latLon.lon).release());
   }
 }
 
-base::Json AddAddress(FeatureBuilder1 const & fb, base::Json regionJson)
+base::Json AddAddress(FeatureBuilder1 const & fb, KeyValue const & regionKeyValue)
 {
-  base::Json result = regionJson.GetDeepCopy();
+  base::Json result = regionKeyValue.second.GetDeepCopy();
   int const kHouseOrPoiRank = 30;
   ToJSONObject(*result.get(), "rank", kHouseOrPoiRank);
-  UpdateCoordinates(fb.GetLimitRect().Center(), result);
+  UpdateCoordinates(fb.GetKeyPoint(), result);
   auto properties = json_object_get(result.get(), "properties");
   auto address = json_object_get(properties, "address");
 
@@ -299,29 +302,25 @@ base::Json AddAddress(FeatureBuilder1 const & fb, base::Json regionJson)
   else
     ToJSONObject(*address, "building", base::NewJSONNull());
 
+  ToJSONObject(*properties, "pid", regionKeyValue.first);
   // auto locales = json_object_get(result.get(), "locales");
   // auto en = json_object_get(result.get(), "en");
   // todo(maksimandrianov): Add en locales.
   return result;
 }
 
-boost::optional<base::Json>
+boost::optional<KeyValue>
 FindRegion(FeatureBuilder1 const & fb, indexer::RegionsIndex<IndexReader> const & regionIndex,
            KeyValueInterface const & regionKv)
 {
-  boost::optional<base::Json> result;
   auto const ids = SearchObjectsInIndex(fb, regionIndex);
-  auto const deepest = GetDeepestRegion(ids, regionKv);
-  if (deepest.get())
-    result = deepest;
-
-  return result;
+  return GetDeepestRegion(ids, regionKv);
 }
 
 std::unique_ptr<char, JSONFreeDeleter>
-MakeGeoObjectValueWithAddress(FeatureBuilder1 const & fb, base::Json json)
+MakeGeoObjectValueWithAddress(FeatureBuilder1 const & fb, KeyValue const & keyValue)
 {
-  auto const jsonWithAddress = AddAddress(fb, json);
+  auto const jsonWithAddress = AddAddress(fb, keyValue);
   auto const cstr = json_dumps(jsonWithAddress.get(), JSON_COMPACT);
   return std::unique_ptr<char, JSONFreeDeleter>(cstr);
 }
@@ -340,14 +339,8 @@ FindHousePoi(FeatureBuilder1 const & fb,
 
     auto properties = json_object_get(house->get(), "properties");
     auto address = json_object_get(properties, "address");
-    std::string const kHouseField = "building";
-    char const * key = nullptr;
-    json_t * value = nullptr;
-    json_object_foreach(address, key, value)
-    {
-      if (key == kHouseField)
-        return house;
-    }
+    if (json_object_get(address, "building"))
+      return house;
   }
 
   return {};
@@ -359,7 +352,7 @@ MakeGeoObjectValueWithoutAddress(FeatureBuilder1 const & fb, base::Json json)
   auto const jsonWithAddress = json.GetDeepCopy();
   auto properties = json_object_get(jsonWithAddress.get(), "properties");
   ToJSONObject(*properties, "name", fb.GetName());
-  UpdateCoordinates(fb.GetLimitRect().Center(), jsonWithAddress);
+  UpdateCoordinates(fb.GetKeyPoint(), jsonWithAddress);
   auto const cstr = json_dumps(jsonWithAddress.get(), JSON_COMPACT);
   return std::unique_ptr<char, JSONFreeDeleter>(cstr);
 }
@@ -367,13 +360,12 @@ MakeGeoObjectValueWithoutAddress(FeatureBuilder1 const & fb, base::Json json)
 boost::optional<indexer::GeoObjectsIndex<IndexReader>>
 MakeTempGeoObjectsIndex(std::string const & pathToGeoObjectsTmpMwm)
 {
-  boost::optional<indexer::GeoObjectsIndex<IndexReader>> result;
   auto const dataFile = Platform().TmpPathForFile();
   SCOPE_GUARD(removeDataFile, std::bind(Platform::RemoveFileIfExists, std::cref(dataFile)));
   if (!feature::GenerateGeoObjectsData(pathToGeoObjectsTmpMwm, "" /* nodesFile */, dataFile))
   {
     LOG(LCRITICAL, ("Error generating geo objects data."));
-    return result;
+    return {};
   }
 
   auto const indexFile = Platform().TmpPathForFile();
@@ -381,57 +373,44 @@ MakeTempGeoObjectsIndex(std::string const & pathToGeoObjectsTmpMwm)
   if (!indexer::BuildGeoObjectsIndexFromDataFile(dataFile, indexFile))
   {
     LOG(LCRITICAL, ("Error generating geo objects index."));
-    return result;
+    return {};
   }
 
-  result = indexer::ReadIndex<indexer::GeoObjectsIndexBox<IndexReader>, MmapReader>(indexFile);
-  return result;
+  return indexer::ReadIndex<indexer::GeoObjectsIndexBox<IndexReader>, MmapReader>(indexFile);
 }
 
-bool BuildGeoObjectsWithAddresses(indexer::RegionsIndex<IndexReader> const & regionIndex,
+void BuildGeoObjectsWithAddresses(indexer::RegionsIndex<IndexReader> const & regionIndex,
                                   KeyValueInterface const & regionKv,
                                   std::string const & pathInGeoObjectsTmpMwm,
                                   std::ostream & streamGeoObjectsKv, bool)
 {
   size_t countGeoObjects = 0;
-  auto const fn = [&](FeatureBuilder1 & fb, uint64_t /* currPos */)
-  {
+  auto const fn = [&](FeatureBuilder1 & fb, uint64_t /* currPos */) {
     if (!(IsBuilding(fb) || HasHouse(fb)))
       return;
 
-    auto region = FindRegion(fb, regionIndex, regionKv);
-    if (!region)
+    auto regionKeyValue = FindRegion(fb, regionIndex, regionKv);
+    if (!regionKeyValue)
       return;
 
-    auto const value = MakeGeoObjectValueWithAddress(fb, *region);
+    auto const value = MakeGeoObjectValueWithAddress(fb, *regionKeyValue);
     streamGeoObjectsKv << static_cast<int64_t>(fb.GetMostGenericOsmId().GetEncodedId()) << " "
                        << value.get() << "\n";
     ++countGeoObjects;
   };
 
-  try
-  {
-    feature::ForEachFromDatRawFormat(pathInGeoObjectsTmpMwm, fn);
-    LOG(LINFO, ("Added ", countGeoObjects, "geo objects with addresses."));
-  }
-  catch (Reader::Exception const & e)
-  {
-    LOG(LERROR, ("Error while reading file:", e.Msg()));
-    return false;
-  }
-
-  return true;
+  feature::ForEachFromDatRawFormat(pathInGeoObjectsTmpMwm, fn);
+  LOG(LINFO, ("Added ", countGeoObjects, "geo objects with addresses."));
 }
 
-bool BuildGeoObjectsWithoutAddresses(indexer::GeoObjectsIndex<IndexReader> const & geoObjectsIndex,
+void BuildGeoObjectsWithoutAddresses(indexer::GeoObjectsIndex<IndexReader> const & geoObjectsIndex,
                                      std::string const & pathInGeoObjectsTmpMwm,
                                      KeyValueInterface const & geoObjectsKv,
                                      std::ostream & streamGeoObjectsKv,
                                      std::ostream & streamIdsWithoutAddress, bool)
 {
   size_t countGeoObjects = 0;
-  auto const fn  = [&](FeatureBuilder1 & fb, uint64_t /* currPos */)
-  {
+  auto const fn  = [&](FeatureBuilder1 & fb, uint64_t /* currPos */) {
     if (IsBuilding(fb) || HasHouse(fb))
       return;
 
@@ -449,18 +428,8 @@ bool BuildGeoObjectsWithoutAddresses(indexer::GeoObjectsIndex<IndexReader> const
     ++countGeoObjects;
   };
 
-  try
-  {
-    feature::ForEachFromDatRawFormat(pathInGeoObjectsTmpMwm, fn);
-    LOG(LINFO, ("Added ", countGeoObjects, "geo objects without addresses."));
-  }
-  catch (Reader::Exception const & e)
-  {
-    LOG(LERROR, ("Error while reading file:", e.Msg()));
-    return false;
-  }
-
-  return true;
+  feature::ForEachFromDatRawFormat(pathInGeoObjectsTmpMwm, fn);
+  LOG(LINFO, ("Added ", countGeoObjects, "geo objects without addresses."));
 }
 }  // namespace
 
@@ -490,12 +459,8 @@ bool GenerateGeoObjects(std::string const & pathInRegionsIndx,
   LOG(LINFO, ("Size of regions key-value storage:", regionsKv.Size()));
   std::ofstream streamIdsWithoutAddress(pathOutIdsWithoutAddress);
   std::ofstream streamGeoObjectsKv(pathOutGeoObjectsKv);
-  if (!BuildGeoObjectsWithAddresses(regionIndex, regionsKv, pathInGeoObjectsTmpMwm,
-                                    streamGeoObjectsKv, verbose))
-  {
-    return false;
-  }
-
+  BuildGeoObjectsWithAddresses(regionIndex, regionsKv, pathInGeoObjectsTmpMwm,
+                               streamGeoObjectsKv, verbose);
   LOG(LINFO, ("Geo objects with addresses were built."));
   // Regions key-value storage is big (~80 Gb). We will not load the key value into memory.
   // This can be slow.
@@ -506,13 +471,11 @@ bool GenerateGeoObjects(std::string const & pathInRegionsIndx,
   LOG(LINFO, ("Size of geo objects key-value storage:", geoObjectsKv.Size()));
   auto const geoObjectIndex = geoObjectIndexFuture.get();
   LOG(LINFO, ("Index was built."));
-  if (!geoObjectIndex ||
-      !BuildGeoObjectsWithoutAddresses(*geoObjectIndex, pathInGeoObjectsTmpMwm, geoObjectsKv,
-                                       streamGeoObjectsKv, streamIdsWithoutAddress, verbose))
-  {
+  if (!geoObjectIndex)
     return false;
-  }
 
+  BuildGeoObjectsWithoutAddresses(*geoObjectIndex, pathInGeoObjectsTmpMwm, geoObjectsKv,
+                                  streamGeoObjectsKv, streamIdsWithoutAddress, verbose);
   LOG(LINFO, ("Geo objects without addresses were built."));
   LOG(LINFO, ("Geo objects key-value storage saved to",  pathOutGeoObjectsKv));
   LOG(LINFO, ("Ids of POIs without addresses saved to", pathOutIdsWithoutAddress));
diff --git a/generator/place_node.hpp b/generator/place_node.hpp
index f705836f94..50b15ef6ba 100644
--- a/generator/place_node.hpp
+++ b/generator/place_node.hpp
@@ -32,6 +32,12 @@ public:
   Data & GetData() { return m_data; }
   Data const & GetData() const { return m_data; }
 
+  void ShrinkToFitChildren()
+  {
+    if (m_children.capacity() != m_children.size())
+      PtrList(m_children).swap(m_children);
+  }
+
 private:
   Data m_data;
   PtrList m_children;
diff --git a/generator/regions/city.hpp b/generator/regions/city.hpp
index 54c9f5bf9b..ce97c10b41 100644
--- a/generator/regions/city.hpp
+++ b/generator/regions/city.hpp
@@ -4,12 +4,15 @@
 #include "generator/regions/collector_region_info.hpp"
 #include "generator/regions/region_base.hpp"
 
+#include <unordered_map>
+
 namespace generator
 {
 namespace regions
 {
-struct City : public RegionWithName, public RegionWithData
+class City : public RegionWithName, public RegionWithData
 {
+public:
   explicit City(FeatureBuilder1 const & fb, RegionDataProxy const & rd)
     : RegionWithName(fb.GetParams().name),
       RegionWithData(rd)
@@ -23,5 +26,7 @@ struct City : public RegionWithName, public RegionWithData
 private:
   BoostPoint m_center;
 };
+
+using PointCitiesMap = std::unordered_map<base::GeoObjectId, City>;
 }  // namespace regions
 }  // namespace generator
diff --git a/generator/regions/collector_region_info.cpp b/generator/regions/collector_region_info.cpp
index a011ed744a..7ad7f8ae59 100644
--- a/generator/regions/collector_region_info.cpp
+++ b/generator/regions/collector_region_info.cpp
@@ -4,7 +4,6 @@
 #include "generator/osm_element.hpp"
 
 #include "coding/file_writer.hpp"
-#include "coding/reader.hpp"
 
 #include "base/assert.hpp"
 #include "base/logging.hpp"
@@ -12,16 +11,12 @@
 
 #include <map>
 
-namespace
-{
-uint8_t const kVersion = 0;
-}  // namespace
-
 namespace generator
 {
 namespace regions
 {
 std::string const CollectorRegionInfo::kDefaultExt = ".regions.bin";
+uint8_t const CollectorRegionInfo::kVersion = 0;
 
 PlaceType EncodePlaceType(std::string const & place)
 {
@@ -58,17 +53,10 @@ void CollectorRegionInfo::Collect(base::GeoObjectId const & osmId, OsmElement co
 
 void CollectorRegionInfo::Save()
 {
-  try
-  {
-    FileWriter writer(m_filename);
-    WriteToSink(writer, kVersion);
-    WriteMap(writer, m_mapRegionData);
-    WriteMap(writer, m_mapIsoCode);
-  }
-  catch (FileWriter::Exception const & e)
-  {
-    LOG(LCRITICAL, ("Failed to save regions info:", e.Msg()));
-  }
+  FileWriter writer(m_filename);
+  WriteToSink(writer, kVersion);
+  WriteMap(writer, m_mapRegionData);
+  WriteMap(writer, m_mapIsoCode);
 }
 
 void CollectorRegionInfo::FillRegionData(base::GeoObjectId const & osmId, OsmElement const & el,
@@ -76,13 +64,6 @@ void CollectorRegionInfo::FillRegionData(base::GeoObjectId const & osmId, OsmEle
 {
   rd.m_osmId = osmId;
   rd.m_place = EncodePlaceType(el.GetTag("place"));
-
-  auto const & members = el.Members();
-  auto const it = std::find_if(std::begin(members), std::end(members),
-                               [](OsmElement::Member const & m) { return m.role == "admin_centre"; });
-  if (it != std::end(members))
-    rd.m_osmIdAdminCenter = base::MakeOsmNode(it->ref);
-
   auto const al = el.GetTag("admin_level");
   if (al.empty())
     return;
@@ -128,156 +109,5 @@ void IsoCode::SetNumeric(std::string const & numeric)
   CHECK_LESS_OR_EQUAL(numeric.size() + 1, ARRAY_SIZE(m_numeric), ());
   std::strcpy(m_numeric, numeric.data());
 }
-
-RegionInfo::RegionInfo(std::string const & filename)
-{
-  ParseFile(filename);
-}
-
-RegionInfo::RegionInfo(Platform::FilesList const & filenames)
-{
-  for (auto const & filename : filenames)
-    ParseFile(filename);
-}
-
-void RegionInfo::ParseFile(std::string const & filename)
-{
-  try
-  {
-    FileReader reader(filename);
-    ReaderSource<FileReader> src(reader);
-    uint8_t version;
-    ReadPrimitiveFromSource(src, version);
-    CHECK_EQUAL(version, kVersion, ("Versions do not match."));
-    ReadMap(src, m_mapRegionData);
-    ReadMap(src, m_mapIsoCode);
-  }
-  catch (FileReader::Exception const & e)
-  {
-    LOG(LCRITICAL, ("Failed to parse regions info:", e.Msg()));
-  }
-}
-
-RegionDataProxy RegionInfo::Get(base::GeoObjectId const & osmId)
-{
-  return RegionDataProxy(*this, osmId);
-}
-
-RegionDataProxy::RegionDataProxy(RegionInfo & regionInfoCollector,
-                                 base::GeoObjectId const & osmId)
-  : m_regionInfoCollector(regionInfoCollector),
-    m_osmId(osmId)
-{
-}
-
-RegionInfo const & RegionDataProxy::GetCollector() const
-{
-  return m_regionInfoCollector;
-}
-
-RegionInfo & RegionDataProxy::GetCollector()
-{
-  return m_regionInfoCollector;
-}
-
-MapRegionData & RegionDataProxy::GetMapRegionData()
-{
-  return GetCollector().m_mapRegionData;
-}
-
-
-MapRegionData const & RegionDataProxy::GetMapRegionData() const
-{
-  return GetCollector().m_mapRegionData;
-}
-
-
-MapIsoCode const & RegionDataProxy::GetMapIsoCode() const
-{
-  return GetCollector().m_mapIsoCode;
-}
-
-base::GeoObjectId const & RegionDataProxy::GetOsmId() const
-{
-  return m_osmId;
-}
-
-AdminLevel RegionDataProxy::GetAdminLevel() const
-{
-  return GetMapRegionData().at(m_osmId).m_adminLevel;
-}
-
-PlaceType RegionDataProxy::GetPlaceType() const
-{
-  return GetMapRegionData().at(m_osmId).m_place;
-}
-
-void RegionDataProxy::SetAdminLevel(AdminLevel adminLevel)
-{
-  GetMapRegionData().at(m_osmId).m_adminLevel = adminLevel;
-}
-
-void RegionDataProxy::SetPlaceType(PlaceType placeType)
-{
-  GetMapRegionData().at(m_osmId).m_place = placeType;
-}
-
-bool RegionDataProxy::HasAdminLevel() const
-{
-  return (GetMapRegionData().count(m_osmId) != 0) &&
-      (GetMapRegionData().at(m_osmId).m_adminLevel != AdminLevel::Unknown);
-}
-
-bool RegionDataProxy::HasPlaceType() const
-{
-  return (GetMapRegionData().count(m_osmId) != 0) &&
-      (GetMapRegionData().at(m_osmId).m_place != PlaceType::Unknown);
-}
-
-bool RegionDataProxy::HasIsoCode() const
-{
-  return GetMapIsoCode().count(m_osmId) != 0;
-}
-
-bool RegionDataProxy::HasIsoCodeAlpha2() const
-{
-  return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasAlpha2();
-}
-
-bool RegionDataProxy::HasIsoCodeAlpha3() const
-{
-  return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasAlpha3();
-}
-
-bool RegionDataProxy::HasIsoCodeAlphaNumeric() const
-{
-  return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasNumeric();
-}
-
-std::string RegionDataProxy::GetIsoCodeAlpha2() const
-{
-  return GetMapIsoCode().at(m_osmId).GetAlpha2();
-}
-
-std::string RegionDataProxy::GetIsoCodeAlpha3() const
-{
-  return GetMapIsoCode().at(m_osmId).GetAlpha3();
-}
-
-std::string RegionDataProxy::GetIsoCodeAlphaNumeric() const
-{
-  return GetMapIsoCode().at(m_osmId).GetNumeric();
-}
-
-bool RegionDataProxy::HasAdminCenter() const
-{
-  return (GetMapRegionData().count(m_osmId) != 0) &&
-      (GetMapRegionData().at(m_osmId).m_osmIdAdminCenter.HasId());
-}
-
-base::GeoObjectId RegionDataProxy::GetAdminCenter() const
-{
-  return GetMapRegionData().at(m_osmId).m_osmIdAdminCenter.GetId();
-}
 }  // namespace regions
 }  // namespace generator
diff --git a/generator/regions/collector_region_info.hpp b/generator/regions/collector_region_info.hpp
index 06fa05414e..975d85ee6c 100644
--- a/generator/regions/collector_region_info.hpp
+++ b/generator/regions/collector_region_info.hpp
@@ -9,12 +9,10 @@
 #include "base/geo_object_id.hpp"
 
 #include <cstdint>
-#include <functional>
 #include <ostream>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
-#include <utility>
 
 struct OsmElement;
 class FeatureParams;
@@ -59,8 +57,6 @@ enum class PlaceType: uint8_t
 
 PlaceType EncodePlaceType(std::string const & place);
 
-class RegionDataProxy;
-
 // Codes for the names of countries, dependent territories, and special areas of geographical
 // interest.
 // https://en.wikipedia.org/wiki/ISO_3166-1
@@ -84,25 +80,11 @@ struct IsoCode
   char m_numeric[4] = {};
 };
 
-struct AdminCenter
-{
-  AdminCenter() : m_has(false) {}
-  AdminCenter(base::GeoObjectId const & id) : m_has(true), m_id(id) {}
-
-  bool HasId() const { return m_has; }
-  base::GeoObjectId GetId() const { return m_id; }
-
-private:
-  bool m_has;
-  base::GeoObjectId m_id;
-};
-
 struct RegionData
 {
   base::GeoObjectId m_osmId;
   AdminLevel m_adminLevel = AdminLevel::Unknown;
   PlaceType m_place = PlaceType::Unknown;
-  AdminCenter m_osmIdAdminCenter;
 };
 
 using MapRegionData = std::unordered_map<base::GeoObjectId, RegionData>;
@@ -112,6 +94,7 @@ using MapIsoCode = std::unordered_map<base::GeoObjectId, IsoCode>;
 class CollectorRegionInfo : public CollectorInterface
 {
 public:
+  static uint8_t const kVersion;
   static std::string const kDefaultExt;
 
   CollectorRegionInfo(std::string const & filename);
@@ -139,76 +122,6 @@ private:
   MapIsoCode m_mapIsoCode;
 };
 
-// RegionInfo class is responsible for reading and accessing additional information about the regions.
-class RegionInfo
-{
-public:
-  RegionInfo() = default;
-  explicit RegionInfo(std::string const & filename);
-  explicit RegionInfo(Platform::FilesList const & filenames);
-
-  RegionDataProxy Get(base::GeoObjectId const & osmId);
-
-private:
-  friend class RegionDataProxy;
-
-  template <typename Source, typename Map>
-  void ReadMap(Source & src, Map & seq)
-  {
-    uint32_t size = 0;
-    ReadPrimitiveFromSource(src, size);
-    typename Map::mapped_type data;
-    for (uint32_t i = 0; i < size; ++i)
-    {
-      ReadPrimitiveFromSource(src, data);
-      seq.emplace(data.m_osmId, std::move(data));
-    }
-  }
-
-  void ParseFile(std::string const & filename);
-
-  MapRegionData m_mapRegionData;
-  MapIsoCode m_mapIsoCode;
-};
-
-class RegionDataProxy
-{
-public:
-  RegionDataProxy(RegionInfo & regionInfoCollector, base::GeoObjectId const & osmId);
-
-  base::GeoObjectId const & GetOsmId() const;
-  AdminLevel GetAdminLevel() const;
-  PlaceType GetPlaceType() const;
-
-  void SetAdminLevel(AdminLevel adminLevel);
-  void SetPlaceType(PlaceType placeType);
-
-  bool HasAdminLevel() const;
-  bool HasPlaceType() const;
-
-  bool HasIsoCodeAlpha2() const;
-  bool HasIsoCodeAlpha3() const;
-  bool HasIsoCodeAlphaNumeric() const;
-
-  std::string GetIsoCodeAlpha2() const;
-  std::string GetIsoCodeAlpha3() const;
-  std::string GetIsoCodeAlphaNumeric() const;
-
-  bool HasAdminCenter() const;
-  base::GeoObjectId GetAdminCenter() const;
-
-private:
-  bool HasIsoCode() const;
-  RegionInfo & GetCollector();
-  RegionInfo const & GetCollector() const;
-  MapRegionData & GetMapRegionData();
-  MapRegionData const & GetMapRegionData() const;
-  MapIsoCode const & GetMapIsoCode() const;
-
-  std::reference_wrapper<RegionInfo> m_regionInfoCollector;
-  base::GeoObjectId m_osmId;
-};
-
 inline std::ostream & operator<<(std::ostream & out, AdminLevel const & t)
 {
   out << static_cast<int>(t);
diff --git a/generator/regions/node.cpp b/generator/regions/node.cpp
index 60284fc21b..9044a71fc7 100644
--- a/generator/regions/node.cpp
+++ b/generator/regions/node.cpp
@@ -1,6 +1,9 @@
 #include "generator/regions/node.hpp"
 
+#include "geometry/mercator.hpp"
+
 #include <algorithm>
+#include <iomanip>
 #include <numeric>
 
 namespace generator
@@ -62,7 +65,9 @@ Node::Ptr MergeHelper(Node::Ptr l, Node::Ptr r, MergeFunc mergeTree)
 
   auto resultChildren = NormalizeChildren(children, mergeTree);
   l->SetChildren(std::move(resultChildren));
+  l->ShrinkToFitChildren();
   r->RemoveChildren();
+  r->ShrinkToFitChildren();
   return l;
 }
 }  // nmespace
@@ -109,17 +114,18 @@ void PrintTree(Node::Ptr node, std::ostream & stream = std::cout, std::string pr
 
   auto const & d = node->GetData();
   auto const point = d.GetCenter();
+  auto const center = MercatorBounds::ToLatLon({point.get<0>(), point.get<1>()});
   stream << d.GetName() << "<" << d.GetEnglishOrTransliteratedName() << "> ("
-         << d.GetId()
+         << DebugPrint(d.GetId())
          << ";" << d.GetLabel()
          << ";" << static_cast<size_t>(d.GetRank())
-         << ";[" << point.get<0>() << "," << point.get<1>() << "])"
+         << ";[" << std::fixed << std::setprecision(7) << center.lat << "," << center.lon << "])"
          << std::endl;
   for (size_t i = 0, size = children.size(); i < size; ++i)
     PrintTree(children[i], stream, prefix, i == size - 1);
 }
 
-void DebugPrintTree(Node::Ptr tree, std::ostream & stream)
+void DebugPrintTree(Node::Ptr const & tree, std::ostream & stream)
 {
   stream << "ROOT NAME: " << tree->GetData().GetName() << std::endl;
   stream << "MAX DEPTH: " <<  MaxDepth(tree) << std::endl;
diff --git a/generator/regions/node.hpp b/generator/regions/node.hpp
index 379fb842ed..b0a505d57c 100644
--- a/generator/regions/node.hpp
+++ b/generator/regions/node.hpp
@@ -15,7 +15,7 @@ size_t TreeSize(Node::Ptr node);
 
 size_t MaxDepth(Node::Ptr node);
 
-void DebugPrintTree(Node::Ptr tree, std::ostream & stream = std::cout);
+void DebugPrintTree(Node::Ptr const & tree, std::ostream & stream = std::cout);
 
 // This function merges two trees if the roots have the same ids.
 Node::Ptr MergeTree(Node::Ptr l, Node::Ptr r);
diff --git a/generator/regions/region.cpp b/generator/regions/region.cpp
index e001c11df3..a5295eabf3 100644
--- a/generator/regions/region.cpp
+++ b/generator/regions/region.cpp
@@ -4,6 +4,8 @@
 #include "generator/regions/city.hpp"
 #include "generator/regions/collector_region_info.hpp"
 
+#include "geometry/mercator.hpp"
+
 #include "base/assert.hpp"
 
 #include <algorithm>
@@ -15,17 +17,66 @@ namespace generator
 {
 namespace regions
 {
+
+BoostPolygon MakePolygonWithRadius(BoostPoint const & point, double radius, size_t numPoints  = 16)
+{
+  boost::geometry::strategy::buffer::point_circle point_strategy(numPoints);
+  boost::geometry::strategy::buffer::distance_symmetric<double> distance_strategy(radius);
+
+  static boost::geometry::strategy::buffer::join_round const join_strategy;
+  static boost::geometry::strategy::buffer::end_round const end_strategy;
+  static boost::geometry::strategy::buffer::side_straight const side_strategy;
+
+  boost::geometry::model::multi_polygon<BoostPolygon> result;
+  boost::geometry::buffer(point, result, distance_strategy, side_strategy, join_strategy,
+                          end_strategy, point_strategy);
+  CHECK_EQUAL(result.size(), 1, ());
+  return std::move(result.front());
+}
 Region::Region(FeatureBuilder1 const & fb, RegionDataProxy const & rd)
-  : RegionWithName(fb.GetParams().name),
-    RegionWithData(rd),
-    m_polygon(std::make_shared<BoostPolygon>())
+  : RegionWithName(fb.GetParams().name)
+  , RegionWithData(rd)
+  , m_polygon(std::make_shared<BoostPolygon>())
 {
   FillPolygon(fb);
-  auto rect = fb.GetLimitRect();
-  m_rect = BoostRect({{rect.minX(), rect.minY()}, {rect.maxX(), rect.maxY()}});
+  boost::geometry::envelope(*m_polygon, m_rect);
   m_area = boost::geometry::area(*m_polygon);
 }
 
+Region::Region(City const & city)
+  : RegionWithName(city.GetMultilangName())
+  , RegionWithData(city.GetRegionData())
+  , m_polygon(std::make_shared<BoostPolygon>())
+{
+  auto const radius = GetRadiusByPlaceType(city.GetPlaceType());
+  *m_polygon = MakePolygonWithRadius(city.GetCenter(), radius);
+  boost::geometry::envelope(*m_polygon, m_rect);
+  m_area = boost::geometry::area(*m_polygon);
+}
+
+// static
+double Region::GetRadiusByPlaceType(PlaceType place)
+{
+  // Based on average radiuses of OSM place polygons.
+  switch (place)
+  {
+  case PlaceType::City:
+    return 0.078;
+  case PlaceType::Town:
+    return 0.033;
+  case PlaceType::Village:
+    return 0.013;
+  case PlaceType::Hamlet:
+    return 0.0067;
+  case PlaceType::Suburb:
+    return 0.016;
+  case PlaceType::Neighbourhood:
+  case PlaceType::IsolatedDwelling:
+    return 0.0035;
+  }
+  UNREACHABLE();
+}
+
 void Region::DeletePolygon()
 {
   m_polygon = nullptr;
@@ -43,12 +94,18 @@ bool Region::IsCountry() const
   return !HasPlaceType() && GetAdminLevel() == kAdminLevelCountry;
 }
 
+bool Region::IsLocality() const
+{
+  return HasPlaceType();
+}
+
 bool Region::Contains(Region const & smaller) const
 {
   CHECK(m_polygon, ());
   CHECK(smaller.m_polygon, ());
 
-  return boost::geometry::covered_by(*smaller.m_polygon, *m_polygon);
+  return boost::geometry::covered_by(smaller.m_rect, m_rect) &&
+      boost::geometry::covered_by(*smaller.m_polygon, *m_polygon);
 }
 
 double Region::CalculateOverlapPercentage(Region const & other) const
@@ -56,6 +113,9 @@ double Region::CalculateOverlapPercentage(Region const & other) const
   CHECK(m_polygon, ());
   CHECK(other.m_polygon, ());
 
+  if (!boost::geometry::intersects(other.m_rect, m_rect))
+    return 0.0;
+
   std::vector<BoostPolygon> coll;
   boost::geometry::intersection(*other.m_polygon, *m_polygon, coll);
   auto const min = std::min(boost::geometry::area(*other.m_polygon),
@@ -81,14 +141,44 @@ bool Region::Contains(City const & cityPoint) const
 {
   CHECK(m_polygon, ());
 
-  return boost::geometry::covered_by(cityPoint.GetCenter(), *m_polygon);
+  return Contains(cityPoint.GetCenter());
 }
 
-void Region::SetInfo(City const & cityPoint)
+bool Region::Contains(BoostPoint const & point) const
 {
-  SetStringUtf8MultilangName(cityPoint.GetStringUtf8MultilangName());
-  SetAdminLevel(cityPoint.GetAdminLevel());
-  SetPlaceType(cityPoint.GetPlaceType());
+  CHECK(m_polygon, ());
+
+  return boost::geometry::covered_by(point, m_rect) &&
+      boost::geometry::covered_by(point, *m_polygon);
+}
+
+bool FeatureCityPointToRegion(RegionInfo const & regionInfo, FeatureBuilder1 & feature)
+{
+  if (!feature.IsPoint())
+    return false;
+
+  auto const center = feature.GetKeyPoint();
+  BoostPolygon polygon;
+  auto info = regionInfo.Get(feature.GetMostGenericOsmId());
+  if (!info.HasPlaceType())
+    return false;
+
+  auto const placeType = info.GetPlaceType();
+  if (placeType == PlaceType::Locality || placeType == PlaceType::Unknown)
+    return false;
+
+  auto const radius = Region::GetRadiusByPlaceType(placeType);
+  polygon = MakePolygonWithRadius({center.x, center.y}, radius);
+  auto const & outer = polygon.outer();
+  FeatureBuilder1::PointSeq seq;
+  std::transform(std::begin(outer), std::end(outer), std::back_inserter(seq), [](BoostPoint const & p) {
+    return m2::PointD(p.get<0>(), p.get<1>());
+  });
+  feature.ResetGeometry();
+  feature.AddPolygon(seq);
+  feature.SetAreaAddHoles({});
+  feature.SetRank(0);
+  return true;
 }
 }  // namespace regions
 }  // namespace generator
diff --git a/generator/regions/region.hpp b/generator/regions/region.hpp
index 2bb352614d..af000e83fd 100644
--- a/generator/regions/region.hpp
+++ b/generator/regions/region.hpp
@@ -13,25 +13,32 @@ class RegionDataProxy;
 
 namespace regions
 {
-struct City;
+class City;
 
 // This is a helper class that is needed to represent the region.
 // With this view, further processing is simplified.
-struct Region : public RegionWithName, public RegionWithData
+class Region : public RegionWithName, public RegionWithData
 {
+public:
   explicit Region(FeatureBuilder1 const & fb, RegionDataProxy const & rd);
+  // Build a region and its boundary based on the heuristic.
+  explicit Region(City const & city);
 
+  // After calling DeletePolygon, you cannot use Contains, ContainsRect, CalculateOverlapPercentage.
   void DeletePolygon();
-  bool IsCountry() const;
   bool Contains(Region const & smaller) const;
   bool ContainsRect(Region const & smaller) const;
+  bool Contains(City const & cityPoint) const;
+  bool Contains(BoostPoint const & point) const;
   double CalculateOverlapPercentage(Region const & other) const;
   BoostPoint GetCenter() const;
-  std::shared_ptr<BoostPolygon> const GetPolygon() const { return m_polygon; }
+  bool IsCountry() const;
+  bool IsLocality() const;
   BoostRect const & GetRect() const { return m_rect; }
   double GetArea() const { return m_area; }
-  bool Contains(City const & cityPoint) const;
-  void SetInfo(City const & cityPoint);
+  // This function uses heuristics and assigns a radius according to the tag place.
+  // The radius will be returned in mercator units.
+  static double GetRadiusByPlaceType(PlaceType place);
 
 private:
   void FillPolygon(FeatureBuilder1 const & fb);
@@ -40,5 +47,7 @@ private:
   BoostRect m_rect;
   double m_area;
 };
+
+bool FeatureCityPointToRegion(RegionInfo const & regionInfo, FeatureBuilder1 & feature);
 }  // namespace regions
 }  // namespace generator
diff --git a/generator/regions/region_base.cpp b/generator/regions/region_base.cpp
index c81f6861ce..795d8fcb43 100644
--- a/generator/regions/region_base.cpp
+++ b/generator/regions/region_base.cpp
@@ -22,8 +22,7 @@ std::string RegionWithName::GetEnglishOrTransliteratedName() const
   if (!s.empty())
     return s;
 
-  auto const fn = [&s](int8_t code, std::string const & name)
-  {
+  auto const fn = [&s](int8_t code, std::string const & name) {
     if (code != StringUtf8Multilang::kDefaultCode &&
         Transliteration::Instance().Transliterate(name, code, s))
     {
@@ -37,12 +36,12 @@ std::string RegionWithName::GetEnglishOrTransliteratedName() const
   return s;
 }
 
-StringUtf8Multilang const & RegionWithName::GetStringUtf8MultilangName() const
+StringUtf8Multilang const & RegionWithName::GetMultilangName() const
 {
   return m_name;
 }
 
-void RegionWithName::SetStringUtf8MultilangName(StringUtf8Multilang const & name)
+void RegionWithName::SetMultilangName(StringUtf8Multilang const & name)
 {
   m_name = name;
 }
@@ -52,16 +51,6 @@ base::GeoObjectId RegionWithData::GetId() const
   return m_regionData.GetOsmId();
 }
 
-bool RegionWithData::HasAdminCenter() const
-{
-  return m_regionData.HasAdminCenter();
-}
-
-base::GeoObjectId RegionWithData::GetAdminCenterId() const
-{
-  return m_regionData.GetAdminCenter();
-}
-
 bool RegionWithData::HasIsoCode() const
 {
   return m_regionData.HasIsoCodeAlpha2();
@@ -88,16 +77,20 @@ uint8_t RegionWithData::GetRank() const
   case PlaceType::Suburb:
   case PlaceType::Neighbourhood:
   case PlaceType::Locality:
-  case PlaceType::IsolatedDwelling: return static_cast<uint8_t>(placeType);
-  default: break;
+  case PlaceType::IsolatedDwelling:
+    return static_cast<uint8_t>(placeType);
+  default:
+    break;
   }
 
   switch (adminLevel)
   {
   case AdminLevel::Two:
   case AdminLevel::Four:
-  case AdminLevel::Six: return static_cast<uint8_t>(adminLevel);
-  default: break;
+  case AdminLevel::Six:
+    return static_cast<uint8_t>(adminLevel);
+  default:
+    break;
   }
 
   return kNoRank;
@@ -113,23 +106,68 @@ std::string RegionWithData::GetLabel() const
   case PlaceType::City:
   case PlaceType::Town:
   case PlaceType::Village:
-  case PlaceType::Hamlet: return "locality";
+  case PlaceType::Hamlet:
+    return "locality";
   case PlaceType::Suburb:
-  case PlaceType::Neighbourhood: return "suburb";
+  case PlaceType::Neighbourhood:
+    return "suburb";
   case PlaceType::Locality:
-  case PlaceType::IsolatedDwelling: return "sublocality";
-  default: break;
+  case PlaceType::IsolatedDwelling:
+    return "sublocality";
+  default:
+    break;
   }
 
   switch (adminLevel)
   {
-  case AdminLevel::Two: return "country";
-  case AdminLevel::Four: return "region";
-  case AdminLevel::Six: return "subregion";
-  default: break;
+  case AdminLevel::Two:
+    return "country";
+  case AdminLevel::Four:
+    return "region";
+  case AdminLevel::Six:
+    return "subregion";
+  default:
+    break;
   }
 
   return "";
 }
+
+size_t RegionWithData::GetWeight() const
+{
+  auto const adminLevel = GetAdminLevel();
+  auto const placeType = GetPlaceType();
+
+  switch (placeType)
+  {
+  case PlaceType::City:
+  case PlaceType::Town:
+  case PlaceType::Village:
+  case PlaceType::Hamlet:
+    return 3;
+  case PlaceType::Suburb:
+  case PlaceType::Neighbourhood:
+    return 2;
+  case PlaceType::Locality:
+  case PlaceType::IsolatedDwelling:
+    return 1;
+  default:
+    break;
+  }
+
+  switch (adminLevel)
+  {
+  case AdminLevel::Two:
+    return 6;
+  case AdminLevel::Four:
+    return 5;
+  case AdminLevel::Six:
+    return 4;
+  default:
+    break;
+  }
+
+  return 0;
+}
 }  // namespace regions
 }  // namespace generator
diff --git a/generator/regions/region_base.hpp b/generator/regions/region_base.hpp
index 7d885fec9e..0143e2292f 100644
--- a/generator/regions/region_base.hpp
+++ b/generator/regions/region_base.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "generator/feature_builder.hpp"
-#include "generator/regions/collector_region_info.hpp"
+#include "generator/regions/region_info.hpp"
 
 #include "geometry/rect2d.hpp"
 
@@ -23,8 +23,9 @@ using BoostPoint = boost::geometry::model::point<double, 2, boost::geometry::cs:
 using BoostPolygon = boost::geometry::model::polygon<BoostPoint>;
 using BoostRect = boost::geometry::model::box<BoostPoint>;
 
-struct RegionWithName
+class RegionWithName
 {
+public:
   RegionWithName(StringUtf8Multilang const & name) : m_name(name) {}
 
   // This function will take the following steps:
@@ -33,22 +34,21 @@ struct RegionWithName
   // 3. Otherwise, return empty string.
   std::string GetEnglishOrTransliteratedName() const;
   std::string GetName(int8_t lang = StringUtf8Multilang::kDefaultCode) const;
-  StringUtf8Multilang const & GetStringUtf8MultilangName() const;
-  void SetStringUtf8MultilangName(StringUtf8Multilang const & name);
+  StringUtf8Multilang const & GetMultilangName() const;
+  void SetMultilangName(StringUtf8Multilang const & name);
 
 protected:
   StringUtf8Multilang m_name;
 };
 
-struct RegionWithData
+class RegionWithData
 {
+public:
   static uint8_t constexpr kNoRank = 0;
 
   RegionWithData(RegionDataProxy const & regionData) : m_regionData(regionData) {}
 
   base::GeoObjectId GetId() const;
-  bool HasAdminCenter() const;
-  base::GeoObjectId GetAdminCenterId() const;
   bool HasIsoCode() const;
   std::string GetIsoCode() const;
 
@@ -56,6 +56,7 @@ struct RegionWithData
   // rank of the second object, then the first object is considered more nested.
   uint8_t GetRank() const;
   std::string GetLabel() const;
+  size_t GetWeight() const;
 
   AdminLevel GetAdminLevel() const { return m_regionData.GetAdminLevel(); }
   PlaceType GetPlaceType() const { return m_regionData.GetPlaceType(); }
@@ -66,6 +67,8 @@ struct RegionWithData
   bool HasAdminLevel() const { return m_regionData.HasAdminLevel(); }
   bool HasPlaceType() const { return m_regionData.HasPlaceType(); }
 
+  RegionDataProxy const & GetRegionData() const { return m_regionData; }
+
 protected:
   RegionDataProxy m_regionData;
 };
diff --git a/generator/regions/region_info.cpp b/generator/regions/region_info.cpp
new file mode 100644
index 0000000000..5233ac53d0
--- /dev/null
+++ b/generator/regions/region_info.cpp
@@ -0,0 +1,166 @@
+#include "generator/regions/region_info.hpp"
+
+#include "generator/regions/collector_region_info.hpp"
+
+#include "coding/file_reader.hpp"
+
+#include "base/assert.hpp"
+#include "base/logging.hpp"
+#include "base/macros.hpp"
+
+namespace generator
+{
+namespace regions
+{
+RegionInfo::RegionInfo(std::string const & filename)
+{
+  ParseFile(filename);
+}
+
+RegionInfo::RegionInfo(Platform::FilesList const & filenames)
+{
+  for (auto const & filename : filenames)
+    ParseFile(filename);
+}
+
+void RegionInfo::ParseFile(std::string const & filename)
+{
+  FileReader reader(filename);
+  ReaderSource<FileReader> src(reader);
+  uint8_t version;
+  ReadPrimitiveFromSource(src, version);
+  CHECK_EQUAL(version, CollectorRegionInfo::kVersion, ());
+  ReadMap(src, m_mapRegionData);
+  ReadMap(src, m_mapIsoCode);
+}
+
+RegionDataProxy RegionInfo::Get(base::GeoObjectId const & osmId)
+{
+  return RegionDataProxy(*this, osmId);
+}
+
+ConstRegionDataProxy RegionInfo::Get(base::GeoObjectId const & osmId) const
+{
+  return ConstRegionDataProxy(*this, osmId);
+}
+
+RegionInfo & RegionDataProxy::GetCollector()
+{
+  return m_regionInfoCollector;
+}
+
+MapRegionData & RegionDataProxy::GetMapRegionData()
+{
+  return GetCollector().m_mapRegionData;
+}
+
+void RegionDataProxy::SetAdminLevel(AdminLevel adminLevel)
+{
+  GetMapRegionData().at(m_osmId).m_adminLevel = adminLevel;
+}
+
+void RegionDataProxy::SetPlaceType(PlaceType placeType)
+{
+  GetMapRegionData().at(m_osmId).m_place = placeType;
+}
+
+template <typename T>
+BaseRegionDataProxy<T>::BaseRegionDataProxy(T & regionInfoCollector, base::GeoObjectId const & osmId)
+  : m_regionInfoCollector(regionInfoCollector), m_osmId(osmId) {}
+
+template <typename T>
+RegionInfo const & BaseRegionDataProxy<T>::GetCollector() const
+{
+  return m_regionInfoCollector;
+}
+
+template <typename T>
+MapRegionData const & BaseRegionDataProxy<T>::GetMapRegionData() const
+{
+  return GetCollector().m_mapRegionData;
+}
+
+template <typename T>
+MapIsoCode const & BaseRegionDataProxy<T>::GetMapIsoCode() const
+{
+  return GetCollector().m_mapIsoCode;
+}
+
+template <typename T>
+base::GeoObjectId const & BaseRegionDataProxy<T>::GetOsmId() const
+{
+  return m_osmId;
+}
+
+template <typename T>
+AdminLevel BaseRegionDataProxy<T>::GetAdminLevel() const
+{
+  return GetMapRegionData().at(m_osmId).m_adminLevel;
+}
+
+template <typename T>
+PlaceType BaseRegionDataProxy<T>::GetPlaceType() const
+{
+  return GetMapRegionData().at(m_osmId).m_place;
+}
+
+template <typename T>
+bool BaseRegionDataProxy<T>::HasAdminLevel() const
+{
+  return (GetMapRegionData().count(m_osmId) != 0) &&
+      (GetMapRegionData().at(m_osmId).m_adminLevel != AdminLevel::Unknown);
+}
+
+template <typename T>
+bool BaseRegionDataProxy<T>::HasPlaceType() const
+{
+  return (GetMapRegionData().count(m_osmId) != 0) &&
+      (GetMapRegionData().at(m_osmId).m_place != PlaceType::Unknown);
+}
+
+template <typename T>
+bool BaseRegionDataProxy<T>::HasIsoCode() const
+{
+  return GetMapIsoCode().count(m_osmId) != 0;
+}
+
+template <typename T>
+bool BaseRegionDataProxy<T>::HasIsoCodeAlpha2() const
+{
+  return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasAlpha2();
+}
+
+template <typename T>
+bool BaseRegionDataProxy<T>::HasIsoCodeAlpha3() const
+{
+  return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasAlpha3();
+}
+
+template <typename T>
+bool BaseRegionDataProxy<T>::HasIsoCodeAlphaNumeric() const
+{
+  return HasIsoCode() && GetMapIsoCode().at(m_osmId).HasNumeric();
+}
+
+template <typename T>
+std::string BaseRegionDataProxy<T>::GetIsoCodeAlpha2() const
+{
+  return GetMapIsoCode().at(m_osmId).GetAlpha2();
+}
+
+template <typename T>
+std::string BaseRegionDataProxy<T>::GetIsoCodeAlpha3() const
+{
+  return GetMapIsoCode().at(m_osmId).GetAlpha3();
+}
+
+template <typename T>
+std::string BaseRegionDataProxy<T>::GetIsoCodeAlphaNumeric() const
+{
+  return GetMapIsoCode().at(m_osmId).GetNumeric();
+}
+
+template class BaseRegionDataProxy<RegionInfo>;
+template class BaseRegionDataProxy<RegionInfo const>;
+}  // namespace regions
+}  // namespace generator
diff --git a/generator/regions/region_info.hpp b/generator/regions/region_info.hpp
new file mode 100644
index 0000000000..131301c7fc
--- /dev/null
+++ b/generator/regions/region_info.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include "generator/regions/collector_region_info.hpp"
+
+#include "platform/platform.hpp"
+
+#include "coding/reader.hpp"
+
+#include "base/geo_object_id.hpp"
+
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <utility>
+
+namespace generator
+{
+namespace regions
+{
+template <typename T>
+class BaseRegionDataProxy;
+class RegionDataProxy;
+class ConstRegionDataProxy;
+
+// RegionInfo class is responsible for reading and accessing additional information about the regions.
+class RegionInfo
+{
+public:
+  RegionInfo() = default;
+  explicit RegionInfo(std::string const & filename);
+  explicit RegionInfo(Platform::FilesList const & filenames);
+
+  RegionDataProxy Get(base::GeoObjectId const & osmId);
+  ConstRegionDataProxy Get(base::GeoObjectId const & osmId) const;
+
+private:
+  friend class BaseRegionDataProxy<RegionInfo>;
+  friend class BaseRegionDataProxy<RegionInfo const>;
+  friend class RegionDataProxy;
+  friend class ConstRegionDataProxy;
+
+  template <typename Source, typename Map>
+  void ReadMap(Source & src, Map & seq)
+  {
+    uint32_t size = 0;
+    ReadPrimitiveFromSource(src, size);
+    typename Map::mapped_type data;
+    for (uint32_t i = 0; i < size; ++i)
+    {
+      ReadPrimitiveFromSource(src, data);
+      seq.emplace(data.m_osmId, std::move(data));
+    }
+  }
+
+  void ParseFile(std::string const & filename);
+
+  MapRegionData m_mapRegionData;
+  MapIsoCode m_mapIsoCode;
+};
+
+template <typename T>
+class BaseRegionDataProxy
+{
+public:
+  BaseRegionDataProxy(T & regionInfoCollector, base::GeoObjectId const & osmId);
+
+  base::GeoObjectId const & GetOsmId() const;
+  AdminLevel GetAdminLevel() const;
+  PlaceType GetPlaceType() const;
+
+  bool HasAdminLevel() const;
+  bool HasPlaceType() const;
+
+  bool HasIsoCodeAlpha2() const;
+  bool HasIsoCodeAlpha3() const;
+  bool HasIsoCodeAlphaNumeric() const;
+
+  std::string GetIsoCodeAlpha2() const;
+  std::string GetIsoCodeAlpha3() const;
+  std::string GetIsoCodeAlphaNumeric() const;
+
+protected:
+  bool HasIsoCode() const;
+  RegionInfo const & GetCollector() const;
+  MapRegionData const & GetMapRegionData() const;
+  MapIsoCode const & GetMapIsoCode() const;
+
+  std::reference_wrapper<T> m_regionInfoCollector;
+  base::GeoObjectId m_osmId;
+};
+
+class ConstRegionDataProxy : public BaseRegionDataProxy<RegionInfo const>
+{
+public:
+  using BaseRegionDataProxy<RegionInfo const>::BaseRegionDataProxy;
+};
+
+class RegionDataProxy : public BaseRegionDataProxy<RegionInfo>
+{
+public:
+  using BaseRegionDataProxy<RegionInfo>::BaseRegionDataProxy;
+
+  void SetAdminLevel(AdminLevel adminLevel);
+  void SetPlaceType(PlaceType placeType);
+
+private:
+  RegionInfo & GetCollector();
+  MapRegionData & GetMapRegionData();
+};
+}  // namespace regions
+}  // namespace generator
diff --git a/generator/regions/regions.cpp b/generator/regions/regions.cpp
index b642b91653..10caf89341 100644
--- a/generator/regions/regions.cpp
+++ b/generator/regions/regions.cpp
@@ -4,8 +4,10 @@
 #include "generator/feature_generator.hpp"
 #include "generator/generate_info.hpp"
 #include "generator/regions/city.hpp"
+#include "generator/regions/regions.hpp"
 #include "generator/regions/node.hpp"
 #include "generator/regions/regions_builder.hpp"
+#include "generator/regions/regions_fixer.hpp"
 #include "generator/regions/to_string_policy.hpp"
 
 #include "platform/platform.hpp"
@@ -13,6 +15,7 @@
 #include "coding/file_name_utils.hpp"
 #include "coding/transliteration.hpp"
 
+#include "base/assert.hpp"
 #include "base/logging.hpp"
 #include "base/stl_helpers.hpp"
 #include "base/timer.hpp"
@@ -37,109 +40,12 @@ namespace regions
 {
 namespace
 {
-using PointCitiesMap = std::unordered_map<base::GeoObjectId, City>;
-
-struct RegionsFixer
-{
-  RegionsFixer(RegionsBuilder::Regions & regions, PointCitiesMap const & pointCitiesMap)
-    : m_regions(regions), m_pointCitiesMap(pointCitiesMap)
-  {
-    SplitRegionsByAdminCenter();
-    CreateNameRegionMap();
-  }
-
-  RegionsBuilder::Regions & FixRegions()
-  {
-    SortRegionsByArea();
-    std::vector<bool> unsuitable;
-    unsuitable.resize(m_regionsWithAdminCenter.size());
-    for (size_t i = 0; i < m_regionsWithAdminCenter.size(); ++i)
-    {
-      if (unsuitable[i])
-        continue;
-
-      auto & regionWithAdminCenter = m_regionsWithAdminCenter[i];
-      if (regionWithAdminCenter.IsCountry())
-        continue;
-
-      auto const id = regionWithAdminCenter.GetAdminCenterId();
-      if (!m_pointCitiesMap.count(id))
-        continue;
-
-      auto const & adminCenter = m_pointCitiesMap.at(id);
-      auto const placeType = adminCenter.GetPlaceType();
-      if (placeType == PlaceType::Town || placeType == PlaceType::City)
-      {
-        for (size_t j = i + 1; j + 1 < m_regionsWithAdminCenter.size(); ++j)
-        {
-          if (m_regionsWithAdminCenter[j].ContainsRect(regionWithAdminCenter))
-            unsuitable[j] = true;
-        }
-      }
-
-      if (RegionExistsAsCity(adminCenter))
-        continue;
-
-      regionWithAdminCenter.SetInfo(adminCenter);
-    }
-
-    std::move(std::begin(m_regionsWithAdminCenter), std::end(m_regionsWithAdminCenter),
-              std::back_inserter(m_regions));
-    m_regionsWithAdminCenter = {};
-    return m_regions;
-  }
-
-private:
-  bool RegionExistsAsCity(City const & city)
-  {
-    auto const range = m_nameRegionMap.equal_range(city.GetName());
-    for (auto it = range.first; it != range.second; ++it)
-    {
-      Region const & r = it->second;
-      if (city.GetRank() == r.GetRank() && r.Contains(city))
-        return true;
-    }
-
-    return false;
-  }
-
-  void SplitRegionsByAdminCenter()
-  {
-    auto const pred = [](Region const & region) { return region.HasAdminCenter(); };
-    std::copy_if(std::begin(m_regions), std::end(m_regions),
-                 std::back_inserter(m_regionsWithAdminCenter), pred);
-    base::EraseIf(m_regions, pred);
-  }
-
-  void CreateNameRegionMap()
-  {
-    for (auto const & region : m_regions)
-    {
-      auto const name = region.GetName();
-      if (region.GetLabel() == "locality" && !name.empty())
-        m_nameRegionMap.emplace(name, region);
-    }
-  }
-
-  void SortRegionsByArea()
-  {
-    auto const cmp = [](Region const & l, Region const & r) { return l.GetArea() < r.GetArea(); };
-    std::sort(std::begin(m_regions), std::end(m_regions), cmp);
-  }
-
-  RegionsBuilder::Regions & m_regions;
-  PointCitiesMap const & m_pointCitiesMap;
-  RegionsBuilder::Regions m_regionsWithAdminCenter;
-  std::multimap<std::string, std::reference_wrapper<Region const>> m_nameRegionMap;
-};
-
 std::tuple<RegionsBuilder::Regions, PointCitiesMap>
 ReadDatasetFromTmpMwm(std::string const & tmpMwmFilename, RegionInfo & collector)
 {
   RegionsBuilder::Regions regions;
   PointCitiesMap pointCitiesMap;
-  auto const toDo = [&regions, &pointCitiesMap, &collector](FeatureBuilder1 const & fb, uint64_t /* currPos */)
-  {
+  auto const toDo = [&](FeatureBuilder1 const & fb, uint64_t /* currPos */) {
     if (fb.IsArea() && fb.IsGeometryClosed())
     {
       auto const id = fb.GetMostGenericOsmId();
@@ -159,36 +65,39 @@ ReadDatasetFromTmpMwm(std::string const & tmpMwmFilename, RegionInfo & collector
 
 void FilterRegions(RegionsBuilder::Regions & regions)
 {
-  auto const pred = [](Region const & region)
-  {
+  auto const pred = [](Region const & region) {
     auto const & label = region.GetLabel();
     auto const & name = region.GetName();
     return label.empty() || name.empty();
   };
-  auto const it = std::remove_if(std::begin(regions), std::end(regions), pred);
-  regions.erase(it, std::end(regions));
+
+  base::EraseIf(regions, pred);
 }
 
-RegionsBuilder::Regions ReadData(std::string const & tmpMwmFilename,
-                                 RegionInfo & regionsInfoCollector)
+RegionsBuilder::Regions ReadAndFixData(std::string const & tmpMwmFilename,
+                                       RegionInfo & regionsInfoCollector)
 {
   RegionsBuilder::Regions regions;
   PointCitiesMap pointCitiesMap;
   std::tie(regions, pointCitiesMap) = ReadDatasetFromTmpMwm(tmpMwmFilename, regionsInfoCollector);
-  RegionsFixer fixer(regions, pointCitiesMap);
-  regions = fixer.FixRegions();
+  FixRegionsWithPlacePointApproximation(pointCitiesMap, regions);
   FilterRegions(regions);
   return regions;
 }
 
 void RepackTmpMwm(std::string const & srcFilename, std::string const & repackedFilename,
-                  std::set<base::GeoObjectId> const & ids)
+                  std::set<base::GeoObjectId> const & ids, RegionInfo const & regionInfo)
 {
   feature::FeaturesCollector collector(repackedFilename);
-  auto const toDo = [&collector, &ids](FeatureBuilder1 const & fb, uint64_t /* currPos */)
-  {
-    if (ids.find(fb.GetMostGenericOsmId()) != std::end(ids))
-      collector(fb);
+  auto const toDo = [&collector, &ids, &regionInfo](FeatureBuilder1 & fb, uint64_t /* currPos */) {
+    if (ids.count(fb.GetMostGenericOsmId()) == 0 ||
+        (fb.IsPoint() && !FeatureCityPointToRegion(regionInfo, fb)))
+    {
+      return;
+    }
+
+    CHECK(fb.IsArea(), ());
+    collector(fb);
   };
 
   feature::ForEachFromDatRawFormat(srcFilename, toDo);
@@ -207,23 +116,21 @@ bool GenerateRegions(std::string const & pathInRegionsTmpMwm,
   Transliteration::Instance().Init(GetPlatform().ResourcesDir());
 
   RegionInfo regionsInfoCollector(pathInRegionsCollector);
-  RegionsBuilder::Regions regions = ReadData(pathInRegionsTmpMwm, regionsInfoCollector);
+  RegionsBuilder::Regions regions = ReadAndFixData(pathInRegionsTmpMwm, regionsInfoCollector);
   auto jsonPolicy = std::make_unique<JsonPolicy>(verbose);
   auto kvBuilder = std::make_unique<RegionsBuilder>(std::move(regions), std::move(jsonPolicy));
-  auto const countryTrees = kvBuilder->GetCountryTrees();
 
   std::ofstream ofs(pathOutRegionsKv, std::ofstream::out);
   std::set<base::GeoObjectId> setIds;
   size_t countIds = 0;
-  for (auto const & countryName : kvBuilder->GetCountryNames())
-  {
-    auto const tree = kvBuilder->GetNormalizedCountryTree(countryName);
+  kvBuilder->ForEachNormalizedCountry([&](std::string const & name, Node::Ptr const & tree) {
     if (!tree)
-      continue;
+      return;
 
     if (verbose)
       DebugPrintTree(tree);
 
+    LOG(LINFO, ("Processing country", name));
     auto const idStringList = kvBuilder->ToIdStringList(tree);
     for (auto const & s : idStringList)
     {
@@ -232,16 +139,17 @@ bool GenerateRegions(std::string const & pathInRegionsTmpMwm,
       if (!setIds.insert(s.first).second)
         LOG(LWARNING, ("Id alredy exists:",  s.first));
     }
-  }
+  });
 
   // todo(maksimandrianov1): Perhaps this is not the best solution. This is a hot fix. Perhaps it
   // is better to transfer this to index generation(function GenerateRegionsData),
   // or to combine index generation and key-value storage generation in
   // generator_tool(generator_tool.cpp).
   if (!pathOutRepackedRegionsTmpMwm.empty())
-    RepackTmpMwm(pathInRegionsTmpMwm, pathOutRepackedRegionsTmpMwm, setIds);
+    RepackTmpMwm(pathInRegionsTmpMwm, pathOutRepackedRegionsTmpMwm, setIds, regionsInfoCollector);
 
-  LOG(LINFO, ("Regions objects key-value storage saved to",  pathOutRegionsKv));
+  LOG(LINFO, ("Regions objects key-value for", kvBuilder->GetCountryNames().size(),
+              "countries storage saved to",  pathOutRegionsKv));
   LOG(LINFO, ("Repacked regions temprory mwm saved to",  pathOutRepackedRegionsTmpMwm));
   LOG(LINFO, (countIds, "total ids.", setIds.size(), "unique ids."));
   LOG(LINFO, ("Finish generating regions.", timer.ElapsedSeconds(), "seconds."));
diff --git a/generator/regions/regions_builder.cpp b/generator/regions/regions_builder.cpp
index 14eedb85be..cb4e3eaa3c 100644
--- a/generator/regions/regions_builder.cpp
+++ b/generator/regions/regions_builder.cpp
@@ -18,22 +18,34 @@ namespace generator
 {
 namespace regions
 {
+namespace
+{
+Node::Ptr ShrinkToFit(Node::Ptr p)
+{
+  p->ShrinkToFitChildren();
+  for (auto ptr : p->GetChildren())
+    ShrinkToFit(ptr);
+
+  return p;
+}
+}  // namespace
+
 RegionsBuilder::RegionsBuilder(Regions && regions,
                                std::unique_ptr<ToStringPolicyInterface> toStringPolicy,
                                int cpuCount)
-  : m_toStringPolicy(std::move(toStringPolicy)),
-    m_cpuCount(cpuCount)
+  : m_toStringPolicy(std::move(toStringPolicy))
+  , m_regions(std::move(regions))
+  , m_cpuCount(cpuCount)
 {
   ASSERT(m_toStringPolicy, ());
   ASSERT(m_cpuCount != 0, ());
 
+
   auto const isCountry = [](Region const & r) { return r.IsCountry(); };
-  std::copy_if(std::begin(regions), std::end(regions), std::back_inserter(m_countries), isCountry);
-  base::EraseIf(regions, isCountry);
+  std::copy_if(std::begin(m_regions), std::end(m_regions), std::back_inserter(m_countries), isCountry);
+  base::EraseIf(m_regions, isCountry);
   auto const cmp = [](Region const & l, Region const & r) { return l.GetArea() > r.GetArea(); };
   std::sort(std::begin(m_countries), std::end(m_countries), cmp);
-
-  MakeCountryTrees(regions);
 }
 
 RegionsBuilder::RegionsBuilder(Regions && regions, int cpuCount)
@@ -58,12 +70,7 @@ RegionsBuilder::StringsList RegionsBuilder::GetCountryNames() const
   return result;
 }
 
-RegionsBuilder::CountryTrees const & RegionsBuilder::GetCountryTrees() const
-{
-  return m_countryTrees;
-}
-
-RegionsBuilder::IdStringList RegionsBuilder::ToIdStringList(Node::Ptr tree) const
+RegionsBuilder::IdStringList RegionsBuilder::ToIdStringList(Node::Ptr const & tree) const
 {
   IdStringList result;
   std::queue<Node::Ptr> queue;
@@ -99,8 +106,7 @@ Node::PtrList RegionsBuilder::MakeSelectedRegionsByCountry(Region const & countr
                std::back_inserter(regionsInCountry), filterCopy);
 
   regionsInCountry.emplace_back(country);
-  auto const comp = [](const Region & l, const Region & r)
-  {
+  auto const comp = [](const Region & l, const Region & r) {
     auto const lArea = l.GetArea();
     auto const rArea = r.GetArea();
     return lArea != rArea ? lArea > rArea : l.GetRank() < r.GetRank();
@@ -127,26 +133,13 @@ Node::Ptr RegionsBuilder::BuildCountryRegionTree(Region const & country,
     for (; itCurr != std::rend(nodes); ++itCurr)
     {
       auto const & currRegion = (*itCurr)->GetData();
-      // If Contains returns false, then we calculate the percent overlap of polygons.
-      // We believe that if one polygon overlaps by 98 percent, then we can assume that one
-      // contains another.
-      auto const kAvaliableOverlapPercentage = 98;
-      if (currRegion.ContainsRect(firstRegion) &&
-          (currRegion.Contains(firstRegion) ||
-           currRegion.CalculateOverlapPercentage(firstRegion) > kAvaliableOverlapPercentage))
+      if (currRegion.Contains(firstRegion) ||
+          (firstRegion.GetWeight() < currRegion.GetWeight() &&
+           currRegion.Contains(firstRegion.GetCenter()) &&
+           currRegion.CalculateOverlapPercentage(firstRegion) > 50.0))
       {
-        // In general, we assume that a region with the larger rank has the larger area.
-        // But sometimes it does not. In this case, we will make an inversion.
-        if (firstRegion.GetRank() < currRegion.GetRank())
-        {
-          (*itCurr)->SetParent(*itFirstNode);
-          (*itFirstNode)->AddChild(*itCurr);
-        }
-        else
-        {
-          (*itFirstNode)->SetParent(*itCurr);
-          (*itCurr)->AddChild(*itFirstNode);
-        }
+        (*itFirstNode)->SetParent(*itCurr);
+        (*itCurr)->AddChild(*itFirstNode);
         // We want to free up memory.
         firstRegion.DeletePolygon();
         nodes.pop_back();
@@ -158,40 +151,44 @@ Node::Ptr RegionsBuilder::BuildCountryRegionTree(Region const & country,
       nodes.pop_back();
   }
 
-  return nodes.empty() ? std::shared_ptr<Node>() : nodes.front();
+  return nodes.empty() ? std::shared_ptr<Node>() : ShrinkToFit(nodes.front());
 }
 
-void RegionsBuilder::MakeCountryTrees(Regions const & regions)
+void RegionsBuilder::ForEachNormalizedCountry(NormalizedCountryFn fn)
 {
-  std::vector<std::future<Node::Ptr>> results;
+  for (auto const & countryName : GetCountryNames())
   {
-    int const cpuCount = m_cpuCount > 0 ? m_cpuCount : std::thread::hardware_concurrency();
+    RegionsBuilder::Regions country;
+    auto const & countries = GetCountries();
+    auto const pred = [&](const Region & r) { return countryName == r.GetName(); };
+    std::copy_if(std::begin(countries), std::end(countries), std::back_inserter(country), pred);
+    auto const countryTrees = BuildCountryRegionTrees(country);
+    auto mergedTree = std::accumulate(std::begin(countryTrees), std::end(countryTrees),
+                                      Node::Ptr(), MergeTree);
+    NormalizeTree(mergedTree);
+    fn(countryName, mergedTree);
+  }
+}
+
+std::vector<Node::Ptr> RegionsBuilder::BuildCountryRegionTrees(RegionsBuilder::Regions const & countries)
+{
+  std::vector<std::future<Node::Ptr>> tmp;
+  {
+    size_t const cpuCount = m_cpuCount > 0 ? static_cast<size_t>(m_cpuCount)
+                                           : std::thread::hardware_concurrency();
     ASSERT_GREATER(cpuCount, 0, ());
     ThreadPool threadPool(cpuCount);
-    for (auto const & country : GetCountries())
+    for (auto const & country : countries)
     {
-      auto result = threadPool.enqueue(&RegionsBuilder::BuildCountryRegionTree, country, regions);
-      results.emplace_back(std::move(result));
+      auto result = threadPool.enqueue(&RegionsBuilder::BuildCountryRegionTree, country, m_regions);
+      tmp.emplace_back(std::move(result));
     }
   }
-
-  for (auto & result : results)
-  {
-    auto tree = result.get();
-    m_countryTrees.emplace(tree->GetData().GetName(), std::move(tree));
-  }
-}
-
-Node::Ptr RegionsBuilder::GetNormalizedCountryTree(std::string const & name)
-{
-  Node::Ptr mergedTree;
-  CountryTrees const & countryTrees = GetCountryTrees();
-  auto const keyRange = countryTrees.equal_range(name);
-  using countryTreeItem = typename RegionsBuilder::CountryTrees::value_type;
-  auto const binOp = [](Node::Ptr l, countryTreeItem r) { return MergeTree(l, r.second); };
-  mergedTree = std::accumulate(keyRange.first, keyRange.second, Node::Ptr(), binOp);
-  NormalizeTree(mergedTree);
-  return mergedTree;
+  std::vector<Node::Ptr> res;
+  res.reserve(tmp.size());
+  std::transform(std::begin(tmp), std::end(tmp),
+                 std::back_inserter(res), [](auto & f) { return f.get(); });
+  return res;
 }
 }  // namespace regions
 }  // namespace generator
diff --git a/generator/regions/regions_builder.hpp b/generator/regions/regions_builder.hpp
index f1f66f99ca..4f5a573fb0 100644
--- a/generator/regions/regions_builder.hpp
+++ b/generator/regions/regions_builder.hpp
@@ -4,6 +4,7 @@
 #include "generator/regions/region.hpp"
 #include "generator/regions/to_string_policy.hpp"
 
+#include <functional>
 #include <map>
 #include <memory>
 #include <string>
@@ -22,6 +23,7 @@ public:
   using StringsList = std::vector<std::string>;
   using IdStringList = std::vector<std::pair<base::GeoObjectId, std::string>>;
   using CountryTrees = std::multimap<std::string, Node::Ptr>;
+  using NormalizedCountryFn = std::function<void(std::string const &, Node::Ptr const &)>;
 
   explicit RegionsBuilder(Regions && regions,
                           std::unique_ptr<ToStringPolicyInterface> toStringPolicy,
@@ -30,19 +32,17 @@ public:
 
   Regions const & GetCountries() const;
   StringsList GetCountryNames() const;
-  CountryTrees const & GetCountryTrees() const;
-  IdStringList ToIdStringList(Node::Ptr tree) const;
-  Node::Ptr GetNormalizedCountryTree(std::string const & name);
-
+  void ForEachNormalizedCountry(NormalizedCountryFn fn);
+  IdStringList ToIdStringList(Node::Ptr const & tree) const;
 private:
   static Node::PtrList MakeSelectedRegionsByCountry(Region const & country,
                                                     Regions const & allRegions);
   static Node::Ptr BuildCountryRegionTree(Region const & country, Regions const & allRegions);
-  void MakeCountryTrees(Regions const & regions);
+  std::vector<Node::Ptr> BuildCountryRegionTrees(RegionsBuilder::Regions const & countries);
 
   std::unique_ptr<ToStringPolicyInterface> m_toStringPolicy;
-  CountryTrees m_countryTrees;
   Regions m_countries;
+  Regions m_regions;
   int m_cpuCount;
 };
 }  // namespace regions
diff --git a/generator/regions/regions_fixer.cpp b/generator/regions/regions_fixer.cpp
new file mode 100644
index 0000000000..bca79bf486
--- /dev/null
+++ b/generator/regions/regions_fixer.cpp
@@ -0,0 +1,100 @@
+#include "generator/regions/regions_fixer.hpp"
+
+#include "base/logging.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <functional>
+#include <iterator>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+
+#include <boost/optional.hpp>
+
+namespace generator
+{
+namespace regions
+{
+namespace
+{
+class RegionLocalityChecker
+{
+public:
+  RegionLocalityChecker() = default;
+  explicit RegionLocalityChecker(RegionsBuilder::Regions const & regions)
+  {
+    for (auto const & region : regions)
+    {
+      auto const name = region.GetName();
+      if (region.IsLocality() && !name.empty())
+        m_nameRegionMap.emplace(std::move(name), region);
+    }
+  }
+
+  bool CityExistsAsRegion(City const & city)
+  {
+    auto const range = m_nameRegionMap.equal_range(city.GetName());
+    for (auto it = range.first; it != range.second; ++it)
+    {
+      Region const & r = it->second;
+      if (city.GetRank() == r.GetRank() && r.Contains(city))
+        return true;
+    }
+
+    return false;
+  }
+
+private:
+  std::multimap<std::string, std::reference_wrapper<Region const>> m_nameRegionMap;
+};
+
+class RegionsFixerWithPlacePointApproximation
+{
+public:
+  explicit RegionsFixerWithPlacePointApproximation(RegionsBuilder::Regions && regions,
+                                                   PointCitiesMap const & pointCitiesMap)
+    : m_regions(std::move(regions)), m_pointCitiesMap(pointCitiesMap) {}
+
+
+  RegionsBuilder::Regions && GetFixedRegions()
+  {
+    RegionLocalityChecker regionsChecker(m_regions);
+    RegionsBuilder::Regions approximatedRegions;
+    size_t countOfFixedRegions = 0;
+    for (auto const & cityKeyValue : m_pointCitiesMap)
+    {
+      auto const & city = cityKeyValue.second;
+      if (!regionsChecker.CityExistsAsRegion(city) && NeedCity(city))
+      {
+        approximatedRegions.push_back(Region(city));
+        ++countOfFixedRegions;
+      }
+    }
+
+    LOG(LINFO, ("City boundaries restored by approximation:", countOfFixedRegions));
+    std::move(std::begin(approximatedRegions), std::end(approximatedRegions),
+              std::back_inserter(m_regions));
+    return std::move(m_regions);
+  }
+
+private:
+  bool NeedCity(const City & city)
+  {
+    return city.HasPlaceType() && city.GetPlaceType() != PlaceType::Locality;
+  }
+
+  RegionsBuilder::Regions m_regions;
+  PointCitiesMap const & m_pointCitiesMap;
+};
+}  // namespace
+
+void FixRegionsWithPlacePointApproximation(PointCitiesMap const & pointCitiesMap,
+                                           RegionsBuilder::Regions & regions)
+{
+  RegionsFixerWithPlacePointApproximation fixer(std::move(regions), pointCitiesMap);
+  regions = fixer.GetFixedRegions();
+}
+}  // namespace regions
+}  // namespace generator
diff --git a/generator/regions/regions_fixer.hpp b/generator/regions/regions_fixer.hpp
new file mode 100644
index 0000000000..1678700bb3
--- /dev/null
+++ b/generator/regions/regions_fixer.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "generator/regions/city.hpp"
+#include "generator/regions/regions_builder.hpp"
+
+#include "base/geo_object_id.hpp"
+
+#include <vector>
+
+namespace generator
+{
+namespace regions
+{
+// This function will build a boundary from point based on place.
+void FixRegionsWithPlacePointApproximation(PointCitiesMap const & pointCitiesMap,
+                                           RegionsBuilder::Regions & regions);
+}  // namespace regions
+}  // namespace generator
diff --git a/generator/regions/to_string_policy.cpp b/generator/regions/to_string_policy.cpp
index 4c78739f83..1c2a430652 100644
--- a/generator/regions/to_string_policy.cpp
+++ b/generator/regions/to_string_policy.cpp
@@ -1,7 +1,11 @@
 #include "generator/regions/to_string_policy.hpp"
 
+#include "geometry/mercator.hpp"
+
+#include <cstdint>
 #include <memory>
 
+#include <boost/optional.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 
 #include "3party/jansson/myjansson.hpp"
@@ -10,7 +14,7 @@ namespace generator
 {
 namespace regions
 {
-std::string JsonPolicy::ToString(Node::PtrList const & nodePtrList)
+std::string JsonPolicy::ToString(Node::PtrList const & nodePtrList) const
 {
   auto const & main = nodePtrList.front()->GetData();
   auto const & country = nodePtrList.back()->GetData();
@@ -18,13 +22,16 @@ std::string JsonPolicy::ToString(Node::PtrList const & nodePtrList)
   auto geometry = base::NewJSONObject();
   ToJSONObject(*geometry, "type", "Point");
   auto coordinates = base::NewJSONArray();
-  auto const center = main.GetCenter();
-  ToJSONArray(*coordinates, center.get<0>());
-  ToJSONArray(*coordinates, center.get<1>());
+  auto const tmpCenter = main.GetCenter();
+  auto const center = MercatorBounds::ToLatLon({tmpCenter.get<0>(), tmpCenter.get<1>()});
+  ToJSONArray(*coordinates, center.lat);
+  ToJSONArray(*coordinates, center.lon);
   ToJSONObject(*geometry, "coordinates", coordinates);
 
   auto localeEn = base::NewJSONObject();
   auto address = base::NewJSONObject();
+  auto const mainLabel = main.GetLabel();
+  boost::optional<int64_t> pid;
   for (auto const & p : boost::adaptors::reverse(nodePtrList))
   {
 
@@ -33,12 +40,14 @@ std::string JsonPolicy::ToString(Node::PtrList const & nodePtrList)
     ToJSONObject(*address, label, region.GetName());
     if (m_extendedOutput)
     {
-      ToJSONObject(*address, label + "_i", region.GetId().GetSerialId());
+      ToJSONObject(*address, label + "_i", DebugPrint(region.GetId()));
       ToJSONObject(*address, label + "_a", region.GetArea());
       ToJSONObject(*address, label + "_r", region.GetRank());
     }
 
     ToJSONObject(*localeEn, label, region.GetEnglishOrTransliteratedName());
+    if (label != mainLabel)
+      pid = static_cast<int64_t>(region.GetId().GetEncodedId());
   }
 
   auto locales = base::NewJSONObject();
@@ -49,6 +58,11 @@ std::string JsonPolicy::ToString(Node::PtrList const & nodePtrList)
   ToJSONObject(*properties, "rank", main.GetRank());
   ToJSONObject(*properties, "address", address);
   ToJSONObject(*properties, "locales", locales);
+  if (pid)
+    ToJSONObject(*properties, "pid", *pid);
+  else
+    ToJSONObject(*properties, "pid", base::NewJSONNull());
+
   if (country.HasIsoCode())
     ToJSONObject(*properties, "code", country.GetIsoCode());
 
diff --git a/generator/regions/to_string_policy.hpp b/generator/regions/to_string_policy.hpp
index b5ca70a60e..dea44d535e 100644
--- a/generator/regions/to_string_policy.hpp
+++ b/generator/regions/to_string_policy.hpp
@@ -13,7 +13,7 @@ class ToStringPolicyInterface
 public:
   virtual ~ToStringPolicyInterface() = default;
 
-  virtual std::string ToString(Node::PtrList const & nodePtrList) = 0;
+  virtual std::string ToString(Node::PtrList const & nodePtrList) const = 0;
 };
 
 class JsonPolicy : public ToStringPolicyInterface
@@ -21,7 +21,7 @@ class JsonPolicy : public ToStringPolicyInterface
 public:
   JsonPolicy(bool extendedOutput = false) : m_extendedOutput(extendedOutput) {}
 
-  std::string ToString(Node::PtrList const & nodePtrList) override;
+  std::string ToString(Node::PtrList const & nodePtrList) const override;
 
 private:
   bool m_extendedOutput;
diff --git a/generator/translator_region.cpp b/generator/translator_region.cpp
index 3af9d5214f..95fdc7f3e4 100644
--- a/generator/translator_region.cpp
+++ b/generator/translator_region.cpp
@@ -30,12 +30,6 @@ bool TranslatorRegion::IsSuitableElement(OsmElement const * p) const
     if (t.key == "place" && places.find(t.value) != places.end())
       return true;
 
-    auto const & members = p->Members();
-    auto const pred = [](OsmElement::Member const & m) { return m.role == "admin_centre"; };
-    if (t.key == "boundary" && t.value == "political" &&
-        std::find_if(std::begin(members), std::end(members), pred) != std::end(members))
-      return true;
-
     if (t.key == "boundary" && t.value == "administrative")
       return true;
   }