diff --git a/base/geo_object_id.hpp b/base/geo_object_id.hpp
index 8d01f7db0d..7e6394c5e9 100644
--- a/base/geo_object_id.hpp
+++ b/base/geo_object_id.hpp
@@ -20,8 +20,8 @@ namespace base
 // Another byte is reserved and the last 6 bytes leave us with 2^48 possible values that can be
 // used for ids within a source.
 // Typically, the reserved byte will be zero but it may be used in future if the format changes.
-// At the time of writing (August 2018), OSM has approximately 2^32 different nodes with ids starting
-// from one (https://wiki.openstreetmap.org/wiki/Stats) and this is by far the largest
+// At the time of writing (August 2018), OSM has approximately 2^32 different nodes with ids
+// starting from one (https://wiki.openstreetmap.org/wiki/Stats) and this is by far the largest
 // serial numbers that we use.
 // The highest bit is zero so that the resulting number is positive if read as a signed 64-bit
 // integer in two's complement notation. This is important for readability in some database systems
diff --git a/generator/feature_builder.hpp b/generator/feature_builder.hpp
index ffba8ac000..fcf08a650f 100644
--- a/generator/feature_builder.hpp
+++ b/generator/feature_builder.hpp
@@ -258,7 +258,8 @@ using TypeSerializationVersion = typename std::underlying_type<SerializationVers
 
 struct MinSize
 {
-  auto static const kSerializationVersion = static_cast<TypeSerializationVersion>(SerializationVersion::MinSize);
+  auto static const kSerializationVersion =
+      static_cast<TypeSerializationVersion>(SerializationVersion::MinSize);
 
   static void Serialize(FeatureBuilder const & fb, FeatureBuilder::Buffer & data)
   {
@@ -273,7 +274,8 @@ struct MinSize
 
 struct MaxAccuracy
 {
-  auto static const kSerializationVersion = static_cast<TypeSerializationVersion>(SerializationVersion::MinSize);
+  auto static const kSerializationVersion =
+      static_cast<TypeSerializationVersion>(SerializationVersion::MinSize);
 
   static void Serialize(FeatureBuilder const & fb, FeatureBuilder::Buffer & data)
   {
@@ -288,10 +290,11 @@ struct MaxAccuracy
 }  // namespace serialization_policy
 
 // 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
+// but this requires reworking of FeatureCollector class and its derived classes. It is in future
+// plans
 
-//template <class SerializationPolicy, class Source>
-//void TryReadAndCheckVersion(Source & src)
+// template <class SerializationPolicy, class Source>
+// void TryReadAndCheckVersion(Source & src)
 //{
 //  if (src.Size() - src.Pos() >= sizeof(serialization_policy::TypeSerializationVersion))
 //  {
@@ -344,7 +347,7 @@ void ForEachParallelFromDatRawFormat(size_t threadsCount, std::string const & fi
 
   FileReader reader(filename);
   ReaderSource<FileReader> src(reader);
-//  TryReadAndCheckVersion<SerializationPolicy>(src);
+  //  TryReadAndCheckVersion<SerializationPolicy>(src);
   auto const fileSize = reader.Size();
   auto currPos = src.Pos();
   std::mutex readMutex;
@@ -394,8 +397,9 @@ public:
     : m_writer(filename, op)
   {
     // 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));
+    // 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)
diff --git a/generator/generator_tests/CMakeLists.txt b/generator/generator_tests/CMakeLists.txt
index ca9bd4772c..ea71add5d6 100644
--- a/generator/generator_tests/CMakeLists.txt
+++ b/generator/generator_tests/CMakeLists.txt
@@ -17,6 +17,7 @@ set(
   feature_builder_test.cpp
   feature_merger_test.cpp
   filter_elements_tests.cpp
+  geo_objects_tests.cpp
   intermediate_data_test.cpp
   maxspeeds_tests.cpp
   merge_collectors_tests.cpp
diff --git a/generator/generator_tests/common.cpp b/generator/generator_tests/common.cpp
index e5bda9408a..0efdb37c97 100644
--- a/generator/generator_tests/common.cpp
+++ b/generator/generator_tests/common.cpp
@@ -1,5 +1,9 @@
 #include "generator/generator_tests/common.hpp"
 
+#include "generator/osm2type.hpp"
+
+#include "indexer/classificator.hpp"
+
 #include "platform/platform.hpp"
 
 #include "base/file_name_utils.hpp"
@@ -17,11 +21,54 @@ OsmElement MakeOsmElement(uint64_t id, Tags const & tags, OsmElement::EntityType
   return el;
 }
 
-std::string GetFileName()
+std::string GetFileName(std::string const & filename)
 {
   auto & platform = GetPlatform();
   auto const tmpDir = platform.TmpDir();
   platform.SetWritableDirForTests(tmpDir);
-  return platform.TmpPathForFile();
+  return filename.empty() ? platform.TmpPathForFile() : platform.TmpPathForFile(filename);
 }
+
+OsmElement MakeOsmElement(OsmElementData const & elementData)
+{
+  OsmElement el;
+  el.m_id = elementData.m_id;
+  el.m_type = elementData.m_polygon.size() > 1 ? OsmElement::EntityType::Relation
+                                               : OsmElement::EntityType::Node;
+  for (auto const & tag : elementData.m_tags)
+    el.AddTag(tag.m_key, tag.m_value);
+  el.m_members = elementData.m_members;
+
+  return el;
+}
+
+feature::FeatureBuilder FeatureBuilderFromOmsElementData(OsmElementData const & elementData)
+{
+  auto el = MakeOsmElement(elementData);
+  feature::FeatureBuilder fb;
+  CHECK(elementData.m_polygon.size() == 1 || elementData.m_polygon.size() == 2, ());
+  if (elementData.m_polygon.size() == 1)
+  {
+    fb.SetCenter(elementData.m_polygon[0]);
+  }
+  else if (elementData.m_polygon.size() == 2)
+  {
+    auto const & p1 = elementData.m_polygon[0];
+    auto const & p2 = elementData.m_polygon[1];
+    vector<m2::PointD> poly = {
+        {p1.x, p1.y}, {p1.x, p2.y}, {p2.x, p2.y}, {p2.x, p1.y}, {p1.x, p1.y}};
+    fb.AddPolygon(poly);
+    fb.SetHoles({});
+    fb.SetArea();
+  }
+
+  auto osmId = el.m_type == OsmElement::EntityType::Relation ? base::MakeOsmRelation(el.m_id)
+                                                             : base::MakeOsmNode(el.m_id);
+  fb.SetOsmId(osmId);
+
+  ftype::GetNameAndType(&el, fb.GetParams(),
+                        [](uint32_t type) { return classif().IsTypeValid(type); });
+  return fb;
+}
+
 }  // namespace generator_tests
diff --git a/generator/generator_tests/common.hpp b/generator/generator_tests/common.hpp
index 929191fc0d..699fa13cf4 100644
--- a/generator/generator_tests/common.hpp
+++ b/generator/generator_tests/common.hpp
@@ -1,7 +1,9 @@
 #pragma once
-
+#include "generator/feature_builder.hpp"
 #include "generator/osm_element.hpp"
 
+#include "geometry/point2d.hpp"
+
 #include <cstdint>
 #include <string>
 
@@ -11,5 +13,30 @@ using Tags = std::vector<std::pair<std::string, std::string>>;
 
 OsmElement MakeOsmElement(uint64_t id, Tags const & tags, OsmElement::EntityType t);
 
-std::string GetFileName();
-} // generator_tests
+std::string GetFileName(std::string const & filename = std::string());
+
+struct TagValue
+{
+  std::string m_key;
+  std::string m_value;
+};
+
+struct Tag
+{
+  TagValue operator=(std::string const & value) const { return {m_name, value}; }
+
+  std::string m_name;
+};
+
+struct OsmElementData
+{
+  uint64_t m_id;
+  std::vector<TagValue> m_tags;
+  std::vector<m2::PointD> m_polygon;
+  std::vector<OsmElement::Member> m_members;
+};
+
+// Use cautiously, nothing means it works with your osm types.
+OsmElement MakeOsmElement(OsmElementData const & elementData);
+feature::FeatureBuilder FeatureBuilderFromOmsElementData(OsmElementData const & elementData);
+}  // namespace generator_tests
diff --git a/generator/generator_tests/geo_objects_tests.cpp b/generator/generator_tests/geo_objects_tests.cpp
new file mode 100644
index 0000000000..f498330b2a
--- /dev/null
+++ b/generator/generator_tests/geo_objects_tests.cpp
@@ -0,0 +1,128 @@
+#include "testing/testing.hpp"
+
+#include "platform/platform_tests_support/scoped_file.hpp"
+
+#include "generator/feature_builder.hpp"
+#include "generator/feature_generator.hpp"
+#include "generator/generator_tests/common.hpp"
+#include "generator/geo_objects/geo_object_info_getter.hpp"
+#include "generator/geo_objects/geo_objects.hpp"
+
+#include "indexer/classificator_loader.hpp"
+
+#include <iostream>
+
+using namespace generator_tests;
+using namespace platform::tests_support;
+using namespace generator;
+using namespace generator::geo_objects;
+using namespace feature;
+using namespace base;
+
+bool CheckWeGotExpectedIdsByPoint(m2::PointD const & point,
+                                  std::vector<base::GeoObjectId> reference,
+                                  indexer::GeoObjectsIndex<IndexReader> const & index)
+{
+  std::vector<base::GeoObjectId> test = GeoObjectInfoGetter::SearchObjectsInIndex(index, point);
+  std::sort(test.begin(), test.end());
+  std::sort(reference.begin(), reference.end());
+  return test == reference;
+}
+
+UNIT_TEST(GenerateGeoObjects_AddNullBuildingGeometryForPointsWithAddressesInside)
+{
+  // Absolutely random region.
+  std::shared_ptr<JsonValue> value = std::make_shared<JsonValue>(LoadFromString(
+      R"({
+               "type": "Feature",
+               "geometry": {
+                 "type": "Point",
+                 "coordinates": [
+                   -77.263927,
+                   26.6210869
+                 ]
+               },
+               "properties": {
+                 "locales": {
+                   "default": {
+                     "address": {
+                       "country": "Bahamas",
+                       "region": "Central Abaco",
+                       "locality": "Leisure Lee"
+                     },
+                     "name": "Leisure Lee"
+                   },
+                   "en": {
+                     "address": {
+                       "country": "Bahamas",
+                       "region": "Central Abaco",
+                       "locality": "Leisure Lee"
+                     },
+                     "name": "Leisure Lee"
+                   },
+                   "ru": {
+                     "address": {
+                       "country": "Багамы"
+                     }
+                   }
+                 },
+                 "rank": 4,
+                 "dref": "C00000000039A088",
+                 "code": "BS"
+               }
+             })"));
+
+  auto regionGetter = [&value](auto && point) { return KeyValue{1, value}; };
+  classificator::Load();
+
+  ScopedFile const geoObjectsFeatures{"geo_objects_features.mwm", ScopedFile::Mode::DoNotCreate};
+  ScopedFile const idsWithoutAddresses{"ids_without_addresses.txt", ScopedFile::Mode::DoNotCreate};
+  ScopedFile const geoObjectsKeyValue{"geo_objects.jsonl", ScopedFile::Mode::DoNotCreate};
+
+  std::vector<base::GeoObjectId> allIds;
+  std::vector<OsmElementData> const osmElements{
+      {1,
+       {{"addr:housenumber", "39 с79"},
+        {"addr:street", "Ленинградский проспект"},
+        {"building", "yes"}},
+       {{1.5, 1.5}},
+       {}},
+      {2,
+       {{"building", "commercial"}, {"type", "multipolygon"}, {"name", "superbuilding"}},
+       {{1, 1}, {4, 4}},
+       {}},
+      {3,
+       {{"addr:housenumber", "39 с80"},
+        {"addr:street", "Ленинградский проспект"},
+        {"building", "yes"}},
+       {{1.6, 1.6}},
+       {}},
+  };
+
+  {
+    FeaturesCollector collector(geoObjectsFeatures.GetFullPath());
+    for (OsmElementData const & elementData : osmElements)
+    {
+      FeatureBuilder fb = FeatureBuilderFromOmsElementData(elementData);
+      allIds.emplace_back(fb.GetMostGenericOsmId());
+      TEST(fb.PreSerialize(), ());
+      collector.Collect(fb);
+    }
+  }
+
+  GeoObjectsGenerator geoObjectsGenerator{regionGetter,
+                                          geoObjectsFeatures.GetFullPath(),
+                                          idsWithoutAddresses.GetFullPath(),
+                                          geoObjectsKeyValue.GetFullPath(),
+                                          "*", /* allowAddresslessForCountries */
+                                          false /* verbose */ ,
+                                          1 /* threadsCount */};
+  TEST(geoObjectsGenerator.GenerateGeoObjects(), ("Generate Geo Objects failed"));
+
+  auto const geoObjectsIndex = MakeTempGeoObjectsIndex(geoObjectsFeatures.GetFullPath());
+  TEST(geoObjectsIndex.has_value(), ("Temporary index build failed"));
+
+  TEST(CheckWeGotExpectedIdsByPoint({1.5, 1.5}, allIds, *geoObjectsIndex), ());
+  TEST(CheckWeGotExpectedIdsByPoint({2, 2}, allIds, *geoObjectsIndex), ());
+  TEST(CheckWeGotExpectedIdsByPoint({4, 4}, allIds, *geoObjectsIndex), ());
+}
diff --git a/generator/generator_tests/regions_tests.cpp b/generator/generator_tests/regions_tests.cpp
index 791dc03947..3f42eb1d10 100644
--- a/generator/generator_tests/regions_tests.cpp
+++ b/generator/generator_tests/regions_tests.cpp
@@ -54,39 +54,6 @@ OsmElement CreateOsmRelation(uint64_t id, std::string const & adminLevel,
   return el;
 }
 
-struct TagValue
-{
-  std::string m_key;
-  std::string m_value;
-};
-
-struct Tag
-{
-  TagValue operator=(std::string const & value) const { return {m_name, value}; }
-
-  std::string m_name;
-};
-
-struct OsmElementData
-{
-  uint64_t m_id;
-  std::vector<TagValue> m_tags;
-  std::vector<m2::PointD> m_polygon;
-  std::vector<OsmElement::Member> m_members;
-};
-
-OsmElement MakeOsmElement(OsmElementData const & elementData)
-{
-  OsmElement el;
-  el.m_id = elementData.m_id;
-  el.m_type = elementData.m_polygon.size() > 1 ? OsmElement::EntityType::Relation
-                                               : OsmElement::EntityType::Node;
-  for (auto const tag : elementData.m_tags)
-    el.AddTag(tag.m_key, tag.m_value);
-  el.m_members = elementData.m_members;
-  return el;
-}
-
 void CollectRegionInfo(std::string const & filename, std::vector<OsmElementData> const & testData)
 {
   CollectorRegionInfo collector(filename);
@@ -105,32 +72,7 @@ void BuildTestData(std::vector<OsmElementData> const & testData, RegionsBuilder:
 {
   for (auto const & elementData : testData)
   {
-    auto el = MakeOsmElement(elementData);
-    FeatureBuilder fb;
-
-    CHECK(elementData.m_polygon.size() == 1 || elementData.m_polygon.size() == 2, ());
-    if (elementData.m_polygon.size() == 1)
-    {
-      fb.SetCenter(elementData.m_polygon[0]);
-    }
-    else if (elementData.m_polygon.size() == 2)
-    {
-      auto const & p1 = elementData.m_polygon[0];
-      auto const & p2 = elementData.m_polygon[1];
-      vector<m2::PointD> poly = {
-          {p1.x, p1.y}, {p1.x, p2.y}, {p2.x, p2.y}, {p2.x, p1.y}, {p1.x, p1.y}};
-      fb.AddPolygon(poly);
-      fb.SetHoles({});
-      fb.SetArea();
-    }
-
-    auto osmId = el.m_type == OsmElement::EntityType::Relation ? MakeOsmRelation(el.m_id)
-                                                               : MakeOsmNode(el.m_id);
-    fb.SetOsmId(osmId);
-
-    FeatureParams params;
-    ftype::GetNameAndType(&el, params, [](uint32_t type) { return classif().IsTypeValid(type); });
-    fb.SetParams(params);
+    FeatureBuilder fb = FeatureBuilderFromOmsElementData(elementData);
 
     auto const id = fb.GetMostGenericOsmId();
     if (elementData.m_polygon.size() == 1)
@@ -422,7 +364,7 @@ UNIT_TEST(RegionsBuilderTest_GenerateCityPointRegionByAround)
       true /* withGeometry */);
 
   TEST(HasName(regions, u8"Nederland, locality: Amsterdam [(0.07, 0.07), (0.23, 0.23)]"),
-      (regions));
+       (regions));
 }
 
 UNIT_TEST(RegionsBuilderTest_GenerateCityPointRegionByNameMatching)
@@ -455,19 +397,25 @@ UNIT_TEST(RegionsBuilderTest_GenerateCityPointRegionByEnglishNameMatching)
 
   auto regions = GenerateTestRegions(
       {
-          {1, {name = u8"België / Belgique / Belgien", admin = "2", ba},
+          {1,
+           {name = u8"België / Belgique / Belgien", admin = "2", ba},
            {{0.00, 0.00}, {0.50, 0.50}}},
-          {3, {name = u8"Ville de Bruxelles - Stad Brussel", admin = "8", ba},
+          {3,
+           {name = u8"Ville de Bruxelles - Stad Brussel", admin = "8", ba},
            {{0.12, 0.12}, {0.18, 0.18}}},
-          {4, {name = u8"Bruxelles / Brussel", {"name:en", "Brussels"}, admin = "9", ba},
+          {4,
+           {name = u8"Bruxelles / Brussel", {"name:en", "Brussels"}, admin = "9", ba},
            {{0.12, 0.12}, {0.17, 0.17}}},
-          {5, {name = u8"Bruxelles - Brussel", {"name:en", "Brussels"}, place = "city"},
+          {5,
+           {name = u8"Bruxelles - Brussel", {"name:en", "Brussels"}, place = "city"},
            {{0.15, 0.15}}},
       },
       true /* withGeometry */);
 
-  TEST(HasName(regions, u8"België / Belgique / Belgien, "
-                        u8"locality: Bruxelles - Brussel [(0.12, 0.12), (0.17, 0.17)]"), ());
+  TEST(HasName(regions,
+               u8"België / Belgique / Belgien, "
+               u8"locality: Bruxelles - Brussel [(0.12, 0.12), (0.17, 0.17)]"),
+       ());
 }
 
 UNIT_TEST(RegionsBuilderTest_GenerateCityPointRegionByNameMatchingWithCityPrefix)
@@ -567,9 +515,7 @@ UNIT_TEST(RegionsBuilderTest_GenerateRusMoscowSubregion)
   });
 
   TEST(HasName(regions, u8"Россия, region: Москва"), ());
-  TEST(HasName(regions,
-               u8"Россия, region: Москва, locality: Москва"),
-       ());
+  TEST(HasName(regions, u8"Россия, region: Москва, locality: Москва"), ());
   TEST(!HasName(regions,
                 u8"Россия, region: Москва, subregion: Западный административный округ, "
                 u8"locality: Москва"),
@@ -582,8 +528,7 @@ UNIT_TEST(RegionsBuilderTest_GenerateRusMoscowSubregion)
                u8"Россия, region: Москва, locality: Москва, "
                u8"subregion: Северный административный округ"),
        ());
-  TEST(HasName(regions,
-               u8"Россия, region: Москва, subregion: Троицкий административный округ"),
+  TEST(HasName(regions, u8"Россия, region: Москва, subregion: Троицкий административный округ"),
        ());
 }
 
diff --git a/generator/generator_tool/generator_tool.cpp b/generator/generator_tool/generator_tool.cpp
index 8b591bfe74..7931cbe695 100644
--- a/generator/generator_tool/generator_tool.cpp
+++ b/generator/generator_tool/generator_tool.cpp
@@ -93,7 +93,8 @@ char const * GetDataPathHelp()
 
 // Coastlines.
 DEFINE_bool(make_coasts, false, "Create intermediate file with coasts data.");
-DEFINE_bool(fail_on_coasts, false, "Stop and exit with '255' code if some coastlines are not merged.");
+DEFINE_bool(fail_on_coasts, false,
+            "Stop and exit with '255' code if some coastlines are not merged.");
 DEFINE_bool(emit_coasts, false,
             "Push coasts features from intermediate file to out files/countries.");
 
@@ -114,8 +115,9 @@ DEFINE_uint64(planet_version, base::SecondsSinceEpoch(),
 DEFINE_bool(preprocess, false, "1st pass - create nodes/ways/relations data.");
 DEFINE_bool(generate_features, false, "2nd pass - generate intermediate features.");
 DEFINE_bool(no_ads, false, "generation without ads.");
-DEFINE_bool(generate_region_features, false,
-            "Generate intermediate features for regions to use in regions index and borders generation.");
+DEFINE_bool(
+    generate_region_features, false,
+    "Generate intermediate features for regions to use in regions index and borders generation.");
 DEFINE_bool(generate_streets_features, false,
             "Generate intermediate features for streets to use in server-side forward geocoder.");
 DEFINE_bool(generate_geo_objects_features, false,
@@ -141,8 +143,9 @@ DEFINE_bool(generate_world, false, "Generate separate world file.");
 DEFINE_bool(split_by_polygons, false,
             "Use countries borders to split planet by regions and countries.");
 
-DEFINE_string(nodes_list_path, "",
-              "Path to file containing list of node ids we need to add to locality index. May be empty.");
+DEFINE_string(
+    nodes_list_path, "",
+    "Path to file containing list of node ids we need to add to locality index. May be empty.");
 
 // Routing.
 DEFINE_bool(make_routing_index, false, "Make sections with the routing information.");
@@ -178,10 +181,8 @@ DEFINE_string(popular_places_data, "",
               "Input Popular Places source file name. Needed both for World intermediate features "
               "generation (2nd pass for World) and popular places section generation (5th pass for "
               "countries).");
-DEFINE_string(brands_data, "",
-              "Path to json with OSM objects to brand ID map.");
-DEFINE_string(brands_translations_data, "",
-              "Path to json with brands translations and synonyms.");
+DEFINE_string(brands_data, "", "Path to json with OSM objects to brand ID map.");
+DEFINE_string(brands_translations_data, "", "Path to json with brands translations and synonyms.");
 
 // Printing stuff.
 DEFINE_bool(calc_statistics, false, "Calculate feature statistics for specified mwm bucket files.");
@@ -194,11 +195,14 @@ DEFINE_string(dump_feature_names, "", "Print all feature names by 2-letter local
 // Service functions.
 DEFINE_bool(generate_classif, false, "Generate classificator.");
 DEFINE_bool(generate_packed_borders, false, "Generate packed file with country polygons.");
-DEFINE_string(unpack_borders, "", "Convert packed_polygons to a directory of polygon files (specify folder).");
-DEFINE_bool(unpack_mwm, false, "Unpack each section of mwm into a separate file with name filePath.sectionName.");
+DEFINE_string(unpack_borders, "",
+              "Convert packed_polygons to a directory of polygon files (specify folder).");
+DEFINE_bool(unpack_mwm, false,
+            "Unpack each section of mwm into a separate file with name filePath.sectionName.");
 DEFINE_bool(check_mwm, false, "Check map file to be correct.");
 DEFINE_string(delete_section, "", "Delete specified section (defines.hpp) from container.");
-DEFINE_bool(generate_addresses_file, false, "Generate .addr file (for '--output' option) with full addresses list.");
+DEFINE_bool(generate_addresses_file, false,
+            "Generate .addr file (for '--output' option) with full addresses list.");
 DEFINE_bool(generate_traffic_keys, false,
             "Generate keys for the traffic map (road segment -> speed group).");
 
@@ -227,7 +231,7 @@ int GeneratorToolMain(int argc, char ** argv)
   CHECK(IsLittleEndian(), ("Only little-endian architectures are supported."));
 
   google::SetUsageMessage(
-        "Takes OSM XML data from stdin and creates data and index files in several passes.");
+      "Takes OSM XML data from stdin and creates data and index files in several passes.");
   google::SetVersionString(std::to_string(omim::build_version::git::kTimestamp) + " " +
                            omim::build_version::git::kHash);
   google::ParseCommandLineFlags(&argc, &argv, true);
@@ -253,9 +257,9 @@ int GeneratorToolMain(int argc, char ** argv)
   feature::GenerateInfo genInfo;
   genInfo.m_verbose = FLAGS_verbose;
 
-  genInfo.m_intermediateDir =
-      FLAGS_intermediate_data_path.empty() ?
-        path : base::AddSlashIfNeeded(FLAGS_intermediate_data_path);
+  genInfo.m_intermediateDir = FLAGS_intermediate_data_path.empty()
+                                  ? path
+                                  : base::AddSlashIfNeeded(FLAGS_intermediate_data_path);
   genInfo.m_targetDir = genInfo.m_tmpDir = path;
 
   /// @todo Probably, it's better to add separate option for .mwm.tmp files.
@@ -394,19 +398,22 @@ int GeneratorToolMain(int argc, char ** argv)
     if (FLAGS_generate_region_features)
     {
       auto emitter = CreateEmitter(EmitterType::SimpleWithPreserialize, genInfo);
-      translators.Append(CreateTranslator(TranslatorType::Regions, emitter, cacheLoader.GetCache(), genInfo));
+      translators.Append(
+          CreateTranslator(TranslatorType::Regions, emitter, cacheLoader.GetCache(), genInfo));
     }
 
     if (FLAGS_generate_streets_features)
     {
       auto emitter = CreateEmitter(EmitterType::SimpleWithPreserialize, genInfo);
-      translators.Append(CreateTranslator(TranslatorType::Streets, emitter, cacheLoader.GetCache()));
+      translators.Append(
+          CreateTranslator(TranslatorType::Streets, emitter, cacheLoader.GetCache()));
     }
 
     if (FLAGS_generate_geo_objects_features)
     {
       auto emitter = CreateEmitter(EmitterType::SimpleWithPreserialize, genInfo);
-      translators.Append(CreateTranslator(TranslatorType::GeoObjects, emitter, cacheLoader.GetCache()));
+      translators.Append(
+          CreateTranslator(TranslatorType::GeoObjects, emitter, cacheLoader.GetCache()));
     }
 
     if (!GenerateRaw(genInfo, translators))
@@ -415,19 +422,23 @@ int GeneratorToolMain(int argc, char ** argv)
 
   if (!FLAGS_streets_key_value.empty())
   {
-    streets::GenerateStreets(FLAGS_regions_index, FLAGS_regions_key_value,
-                             FLAGS_streets_features, FLAGS_geo_objects_features,
-                             FLAGS_streets_key_value,
-                             FLAGS_verbose, threadsCount);
+    streets::GenerateStreets(FLAGS_regions_index, FLAGS_regions_key_value, FLAGS_streets_features,
+                             FLAGS_geo_objects_features, FLAGS_streets_key_value, FLAGS_verbose,
+                             threadsCount);
   }
 
   if (!FLAGS_geo_objects_key_value.empty())
   {
-    if (!geo_objects::GenerateGeoObjects(FLAGS_regions_index, FLAGS_regions_key_value,
-                                         FLAGS_geo_objects_features, FLAGS_ids_without_addresses,
-                                         FLAGS_geo_objects_key_value,
-                                         FLAGS_allow_addressless_for_countries,
-                                         FLAGS_verbose, threadsCount))
+    geo_objects::GeoObjectsGenerator geoObjectsGenerator{FLAGS_regions_index,
+                                                         FLAGS_regions_key_value,
+                                                         FLAGS_geo_objects_features,
+                                                         FLAGS_ids_without_addresses,
+                                                         FLAGS_geo_objects_key_value,
+                                                         FLAGS_allow_addressless_for_countries,
+                                                         FLAGS_verbose,
+                                                         threadsCount};
+
+    if (!geoObjectsGenerator.GenerateGeoObjects())
       return EXIT_FAILURE;
   }
 
@@ -446,7 +457,8 @@ int GeneratorToolMain(int argc, char ** argv)
     auto const outFile = base::JoinPath(path, FLAGS_output + LOC_IDX_FILE_EXTENSION);
     if (FLAGS_generate_geo_objects_index)
     {
-      if (!feature::GenerateGeoObjectsData(FLAGS_geo_objects_features, FLAGS_nodes_list_path, locDataFile))
+      if (!feature::GenerateGeoObjectsData(FLAGS_geo_objects_features, FLAGS_nodes_list_path,
+                                           locDataFile))
       {
         LOG(LCRITICAL, ("Error generating geo objects data."));
         return EXIT_FAILURE;
@@ -488,10 +500,11 @@ int GeneratorToolMain(int argc, char ** argv)
   {
     CHECK(FLAGS_generate_region_features, ("Option --generate_regions_kv can be used only "
                                            "together with option --generate_region_features."));
-    auto const pathInRegionsCollector = genInfo.GetTmpFileName(genInfo.m_fileName,
-                                                               regions::CollectorRegionInfo::kDefaultExt);
+    auto const pathInRegionsCollector =
+        genInfo.GetTmpFileName(genInfo.m_fileName, regions::CollectorRegionInfo::kDefaultExt);
     auto const pathInRegionsTmpMwm = genInfo.GetTmpFileName(genInfo.m_fileName);
-    auto const pathOutRepackedRegionsTmpMwm = genInfo.GetTmpFileName(genInfo.m_fileName + "_repacked");
+    auto const pathOutRepackedRegionsTmpMwm =
+        genInfo.GetTmpFileName(genInfo.m_fileName + "_repacked");
     auto const pathOutRegionsKv = genInfo.GetIntermediateFileName(genInfo.m_fileName, ".jsonl");
     regions::GenerateRegions(pathInRegionsTmpMwm, pathInRegionsCollector, pathOutRegionsKv,
                              pathOutRepackedRegionsTmpMwm, FLAGS_verbose, threadsCount);
@@ -548,8 +561,7 @@ int GeneratorToolMain(int argc, char ** argv)
 
       if (mapType == MapType::Country)
       {
-        string const metalinesFilename =
-            genInfo.GetIntermediateFileName(METALINES_FILENAME);
+        string const metalinesFilename = genInfo.GetIntermediateFileName(METALINES_FILENAME);
 
         LOG(LINFO, ("Processing metalines from", metalinesFilename));
         if (!feature::WriteMetalinesSection(datFile, metalinesFilename, osmToFeatureFilename))
@@ -616,8 +628,7 @@ int GeneratorToolMain(int argc, char ** argv)
       }
       else
       {
-        string const camerasFilename =
-            genInfo.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME);
+        string const camerasFilename = genInfo.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME);
 
         BuildCamerasInfo(datFile, camerasFilename, osmToFeatureFilename);
       }
@@ -628,19 +639,18 @@ int GeneratorToolMain(int argc, char ** argv)
       if (!countryParentGetter)
       {
         // All the mwms should use proper VehicleModels.
-        LOG(LCRITICAL, ("Countries file is needed. Please set countries file name (countries.txt or "
-                        "countries_obsolete.txt). File must be located in data directory."));
+        LOG(LCRITICAL,
+            ("Countries file is needed. Please set countries file name (countries.txt or "
+             "countries_obsolete.txt). File must be located in data directory."));
         return EXIT_FAILURE;
       }
 
-      string const restrictionsFilename =
-          genInfo.GetIntermediateFileName(RESTRICTIONS_FILENAME);
-      string const roadAccessFilename =
-          genInfo.GetIntermediateFileName(ROAD_ACCESS_FILENAME);
+      string const restrictionsFilename = genInfo.GetIntermediateFileName(RESTRICTIONS_FILENAME);
+      string const roadAccessFilename = genInfo.GetIntermediateFileName(ROAD_ACCESS_FILENAME);
 
       routing::BuildRoutingIndex(datFile, country, *countryParentGetter);
-      routing::BuildRoadRestrictions(path, datFile, country, restrictionsFilename, osmToFeatureFilename,
-                                     *countryParentGetter);
+      routing::BuildRoadRestrictions(path, datFile, country, restrictionsFilename,
+                                     osmToFeatureFilename, *countryParentGetter);
       routing::BuildRoadAccessInfo(datFile, roadAccessFilename, osmToFeatureFilename);
     }
 
@@ -667,15 +677,17 @@ int GeneratorToolMain(int argc, char ** argv)
       if (!countryParentGetter)
       {
         // All the mwms should use proper VehicleModels.
-        LOG(LCRITICAL, ("Countries file is needed. Please set countries file name (countries.txt or "
-                        "countries_obsolete.txt). File must be located in data directory."));
+        LOG(LCRITICAL,
+            ("Countries file is needed. Please set countries file name (countries.txt or "
+             "countries_obsolete.txt). File must be located in data directory."));
         return EXIT_FAILURE;
       }
 
       if (FLAGS_make_cross_mwm)
       {
         routing::BuildRoutingCrossMwmSection(path, datFile, country, *countryParentGetter,
-                                             osmToFeatureFilename, FLAGS_disable_cross_mwm_progress);
+                                             osmToFeatureFilename,
+                                             FLAGS_disable_cross_mwm_progress);
       }
 
       if (FLAGS_make_transit_cross_mwm)
diff --git a/generator/geo_objects/geo_object_info_getter.cpp b/generator/geo_objects/geo_object_info_getter.cpp
index a54054c8b3..957ac9b226 100644
--- a/generator/geo_objects/geo_object_info_getter.cpp
+++ b/generator/geo_objects/geo_object_info_getter.cpp
@@ -11,11 +11,46 @@ GeoObjectInfoGetter::GeoObjectInfoGetter(indexer::GeoObjectsIndex<IndexReader> &
     : m_index{std::move(index)}, m_storage{kvStorage}
 { }
 
-std::vector<base::GeoObjectId> GeoObjectInfoGetter::SearchObjectsInIndex(m2::PointD const & point) const
+std::shared_ptr<JsonValue> GeoObjectInfoGetter::Find(
+    m2::PointD const & point, std::function<bool(JsonValue const &)> && pred) const
+{
+  auto const ids = SearchObjectsInIndex(m_index, point);
+  for (auto const & id : ids)
+  {
+    auto const object = m_storage.Find(id.GetEncodedId());
+    if (!object)
+      continue;
+
+    if (pred(std::cref(*object)))
+      return object;
+  }
+
+  return {};
+}
+
+boost::optional<base::GeoObjectId> GeoObjectInfoGetter::Search(
+    m2::PointD const & point, std::function<bool(JsonValue const &)> && pred) const
+{
+  auto const ids = SearchObjectsInIndex(m_index, point);
+  for (auto const & id : ids)
+  {
+    auto const object = m_storage.Find(id.GetEncodedId());
+    if (!object)
+      continue;
+
+    if (pred(std::cref(*object)))
+      return id;
+  }
+
+  return {};
+}
+
+std::vector<base::GeoObjectId> GeoObjectInfoGetter::SearchObjectsInIndex(
+    indexer::GeoObjectsIndex<IndexReader> const & index, m2::PointD const & point)
 {
   std::vector<base::GeoObjectId> ids;
-  auto const emplace = [&ids] (base::GeoObjectId const & osmId) { ids.emplace_back(osmId); };
-  m_index.ForEachAtPoint(emplace, point);
+  auto const emplace = [&ids](base::GeoObjectId const & osmId) { ids.emplace_back(osmId); };
+  index.ForEachAtPoint(emplace, point);
   return ids;
 }
 }  // namespace geo_objects
diff --git a/generator/geo_objects/geo_object_info_getter.hpp b/generator/geo_objects/geo_object_info_getter.hpp
index 5d9ec06cf2..a9ed693610 100644
--- a/generator/geo_objects/geo_object_info_getter.hpp
+++ b/generator/geo_objects/geo_object_info_getter.hpp
@@ -28,34 +28,21 @@ class GeoObjectInfoGetter
 public:
   using IndexReader = ReaderPtr<Reader>;
 
-  GeoObjectInfoGetter(indexer::GeoObjectsIndex<IndexReader> && index, KeyValueStorage const & kvStorage);
+  GeoObjectInfoGetter(indexer::GeoObjectsIndex<IndexReader> && index,
+                      KeyValueStorage const & kvStorage);
 
-  template <typename Predicate>
-  std::shared_ptr<JsonValue> Find(m2::PointD const & point, Predicate && pred) const;
+  std::shared_ptr<JsonValue> Find(m2::PointD const & point,
+                                  std::function<bool(JsonValue const &)> && pred) const;
+
+  boost::optional<base::GeoObjectId> Search(
+      m2::PointD const & point, std::function<bool(JsonValue const &)> && pred) const;
+
+  static std::vector<base::GeoObjectId> SearchObjectsInIndex(
+      indexer::GeoObjectsIndex<IndexReader> const & index, m2::PointD const & point);
 
 private:
-  std::vector<base::GeoObjectId> SearchObjectsInIndex(m2::PointD const & point) const;
-
   indexer::GeoObjectsIndex<IndexReader> m_index;
   KeyValueStorage const & m_storage;
 };
-
-template <typename Predicate>
-std::shared_ptr<JsonValue> GeoObjectInfoGetter::Find(
-    m2::PointD const & point, Predicate && pred) const
-{
-  auto const ids = SearchObjectsInIndex(point);
-  for (auto const & id : ids)
-  {
-    auto const object = m_storage.Find(id.GetEncodedId());
-    if (!object)
-      continue;
-
-    if (pred(std::cref(*object)))
-      return object;
-  }
-
-  return {};
-}
 }  // namespace geo_objects
 }  // namespace generator
diff --git a/generator/geo_objects/geo_objects.cpp b/generator/geo_objects/geo_objects.cpp
index b6f32ad2d3..9ce2bb3cdf 100644
--- a/generator/geo_objects/geo_objects.cpp
+++ b/generator/geo_objects/geo_objects.cpp
@@ -7,7 +7,6 @@
 #include "generator/key_value_storage.hpp"
 #include "generator/locality_sorter.hpp"
 #include "generator/regions/region_base.hpp"
-#include "generator/regions/region_info_getter.hpp"
 
 #include "indexer/classificator.hpp"
 #include "indexer/ftypes_matcher.hpp"
@@ -16,11 +15,11 @@
 
 #include "coding/mmap_reader.hpp"
 
+#include "coding/internal/file_data.hpp"
+
 #include "geometry/mercator.hpp"
 
 #include "base/geo_object_id.hpp"
-#include "base/logging.hpp"
-#include "base/timer.hpp"
 
 #include <cstdint>
 #include <fstream>
@@ -28,8 +27,6 @@
 #include <future>
 #include <mutex>
 
-#include "platform/platform.hpp"
-
 #include <boost/optional.hpp>
 
 #include "3party/jansson/myjansson.hpp"
@@ -42,8 +39,6 @@ namespace geo_objects
 {
 namespace
 {
-using IndexReader = ReaderPtr<Reader>;
-
 bool HouseHasAddress(JsonValue const & json)
 {
   auto && address =
@@ -115,34 +110,11 @@ base::JSONPtr MakeGeoObjectValueWithoutAddress(FeatureBuilder const & fb, JsonVa
   return jsonWithAddress;
 }
 
-boost::optional<indexer::GeoObjectsIndex<IndexReader>> MakeTempGeoObjectsIndex(
-    std::string const & pathToGeoObjectsTmpMwm)
+void FilterAddresslessByCountryAndRepackMwm(
+    std::string const & pathInGeoObjectsTmpMwm, std::string const & includeCountries,
+    GeoObjectsGenerator::RegionInfoGetterProxy const & regionInfoGetter, size_t threadsCount)
 {
-  auto const dataFile = Platform().TmpPathForFile();
-  SCOPE_GUARD(removeDataFile, std::bind(Platform::RemoveFileIfExists, std::cref(dataFile)));
-  if (!GenerateGeoObjectsData(pathToGeoObjectsTmpMwm, "" /* nodesFile */, dataFile))
-  {
-    LOG(LCRITICAL, ("Error generating geo objects data."));
-    return {};
-  }
-
-  auto const indexFile = Platform().TmpPathForFile();
-  SCOPE_GUARD(removeIndexFile, std::bind(Platform::RemoveFileIfExists, std::cref(indexFile)));
-  if (!indexer::BuildGeoObjectsIndexFromDataFile(dataFile, indexFile))
-  {
-    LOG(LCRITICAL, ("Error generating geo objects index."));
-    return {};
-  }
-
-  return indexer::ReadIndex<indexer::GeoObjectsIndexBox<IndexReader>, MmapReader>(indexFile);
-}
-
-void FilterAddresslessByCountryAndRepackMwm(std::string const & pathInGeoObjectsTmpMwm,
-                                            std::string const & includeCountries,
-                                            regions::RegionInfoGetter const & regionInfoGetter,
-                                            size_t threadsCount)
-{
-  auto const path = Platform().TmpPathForFile();
+  auto const path = GetPlatform().TmpPathForFile();
   FeaturesCollector collector(path);
   std::mutex collectorMutex;
   auto concurrentCollect = [&](FeatureBuilder const & fb) {
@@ -173,16 +145,13 @@ void FilterAddresslessByCountryAndRepackMwm(std::string const & pathInGeoObjects
   };
 
   ForEachParallelFromDatRawFormat(threadsCount, pathInGeoObjectsTmpMwm, filteringCollector);
-
-  Platform().RemoveFileIfExists(pathInGeoObjectsTmpMwm);
-  if (std::rename(path.c_str(), pathInGeoObjectsTmpMwm.c_str()) != 0)
-    LOG(LERROR, ("Error: Cannot rename", path, "to", pathInGeoObjectsTmpMwm));
+  CHECK(base::RenameFileX(path, pathInGeoObjectsTmpMwm), ());
 }
 
-void BuildGeoObjectsWithAddresses(KeyValueStorage & geoObjectsKv,
-                                  regions::RegionInfoGetter const & regionInfoGetter,
-                                  std::string const & pathInGeoObjectsTmpMwm, bool verbose,
-                                  size_t threadsCount)
+void AddThingsWithHousesAndBuildingsAndEnrichWithRegionAddresses(
+    KeyValueStorage & geoObjectsKv,
+    GeoObjectsGenerator::RegionInfoGetterProxy const & regionInfoGetter,
+    std::string const & pathInGeoObjectsTmpMwm, bool verbose, size_t threadsCount)
 {
   std::mutex updateMutex;
   auto const concurrentTransformer = [&](FeatureBuilder & fb, uint64_t /* currPos */) {
@@ -204,13 +173,13 @@ void BuildGeoObjectsWithAddresses(KeyValueStorage & geoObjectsKv,
   LOG(LINFO, ("Added", geoObjectsKv.Size(), "geo objects with addresses."));
 }
 
-void BuildGeoObjectsWithoutAddresses(KeyValueStorage & geoObjectsKv,
-                                     GeoObjectInfoGetter const & geoObjectInfoGetter,
-                                     std::string const & pathInGeoObjectsTmpMwm,
-                                     std::ostream & streamIdsWithoutAddress, bool verbose,
-                                     size_t threadsCount)
+void AddPoisEnrichedWithHouseAddresses(KeyValueStorage & geoObjectsKv,
+                                       GeoObjectInfoGetter const & geoObjectInfoGetter,
+                                       std::string const & pathInGeoObjectsTmpMwm,
+                                       std::ostream & streamIdsWithoutAddress, bool verbose,
+                                       size_t threadsCount)
 {
-  auto addressObjectsCount = geoObjectsKv.Size();
+  auto const addressObjectsCount = geoObjectsKv.Size();
 
   std::mutex updateMutex;
   auto const concurrentTransformer = [&](FeatureBuilder & fb, uint64_t /* currPos */) {
@@ -235,53 +204,240 @@ void BuildGeoObjectsWithoutAddresses(KeyValueStorage & geoObjectsKv,
   LOG(LINFO,
       ("Added ", geoObjectsKv.Size() - addressObjectsCount, "geo objects without addresses."));
 }
+
+struct NullBuildingsInfo
+{
+  std::unordered_map<base::GeoObjectId, base::GeoObjectId> m_addressPoints2Buildings;
+  std::set<base::GeoObjectId> m_buildingsIds;
+};
+
+NullBuildingsInfo GetHelpfulNullBuildings(GeoObjectInfoGetter const & geoObjectInfoGetter,
+                                          std::string const & pathInGeoObjectsTmpMwm,
+                                          size_t threadsCount)
+{
+  NullBuildingsInfo result;
+
+  std::mutex updateMutex;
+  auto const saveIdFold = [&](FeatureBuilder & fb, uint64_t /* currPos */) {
+    if (!GeoObjectsFilter::HasHouse(fb) || !fb.IsPoint())
+      return;
+
+    auto const buildingId = geoObjectInfoGetter.Search(
+        fb.GetKeyPoint(), [](JsonValue const & json) { return !HouseHasAddress(json); });
+    if (!buildingId)
+      return;
+
+    auto const id = fb.GetMostGenericOsmId();
+
+    std::lock_guard<std::mutex> lock(updateMutex);
+    result.m_addressPoints2Buildings[id] = *buildingId;
+    result.m_buildingsIds.insert(*buildingId);
+  };
+
+  ForEachParallelFromDatRawFormat(threadsCount, pathInGeoObjectsTmpMwm, saveIdFold);
+  return result;
+}
+
+using BuildingsGeometries =
+    std::unordered_map<base::GeoObjectId, feature::FeatureBuilder::Geometry>;
+
+BuildingsGeometries GetBuildingsGeometry(std::string const & pathInGeoObjectsTmpMwm,
+                                         NullBuildingsInfo const & buildingsInfo,
+                                         size_t threadsCount)
+{
+  BuildingsGeometries result;
+  std::mutex updateMutex;
+
+  auto const saveIdFold = [&](FeatureBuilder & fb, uint64_t /* currPos */) {
+    auto const id = fb.GetMostGenericOsmId();
+    if (buildingsInfo.m_buildingsIds.find(id) == buildingsInfo.m_buildingsIds.end() ||
+        fb.GetParams().GetGeomType() != feature::GeomType::Area)
+      return;
+
+    std::lock_guard<std::mutex> lock(updateMutex);
+
+    if (result.find(id) != result.end())
+      LOG(LINFO, ("More than one geometry for", id));
+    else
+      result[id] = fb.GetGeometry();
+  };
+
+  ForEachParallelFromDatRawFormat(threadsCount, pathInGeoObjectsTmpMwm, saveIdFold);
+  return result;
+}
+
+size_t AddBuildingGeometriesToAddressPoints(std::string const & pathInGeoObjectsTmpMwm,
+                                            NullBuildingsInfo const & buildingsInfo,
+                                            BuildingsGeometries const & geometries,
+                                            size_t threadsCount)
+{
+  auto const path = GetPlatform().TmpPathForFile();
+  FeaturesCollector collector(path);
+  std::atomic_size_t pointsEnriched{0};
+  std::mutex collectorMutex;
+
+  auto concurrentCollector = [&](FeatureBuilder & fb, uint64_t /* currPos */) {
+    auto const id = fb.GetMostGenericOsmId();
+    auto point2BuildingIt = buildingsInfo.m_addressPoints2Buildings.find(id);
+    if (point2BuildingIt != buildingsInfo.m_addressPoints2Buildings.end())
+    {
+      auto const & geometry = geometries.at(point2BuildingIt->second);
+
+      // ResetGeometry does not reset center but SetCenter changes geometry type to Point and
+      // adds center to bounding rect
+      fb.SetCenter({});
+      // ResetGeometry clears bounding rect
+      fb.ResetGeometry();
+      fb.GetParams().SetGeomType(feature::GeomType::Area);
+
+      for (std::vector<m2::PointD> poly : geometry)
+        fb.AddPolygon(poly);
+
+      fb.PreSerialize();
+      ++pointsEnriched;
+    }
+    std::lock_guard<std::mutex> lock(collectorMutex);
+    collector.Collect(fb);
+  };
+
+  ForEachParallelFromDatRawFormat(threadsCount, pathInGeoObjectsTmpMwm, concurrentCollector);
+
+  CHECK(base::RenameFileX(path, pathInGeoObjectsTmpMwm), ());
+  return pointsEnriched;
+}
+
+void EnrichPointsWithOuterBuildingGeometry(GeoObjectInfoGetter const & geoObjectInfoGetter,
+                                           std::string const & pathInGeoObjectsTmpMwm,
+                                           size_t threadsCount)
+{
+  auto const buildingInfo =
+      GetHelpfulNullBuildings(geoObjectInfoGetter, pathInGeoObjectsTmpMwm, threadsCount);
+
+  LOG(LINFO, ("Found", buildingInfo.m_addressPoints2Buildings.size(),
+              "address points with outer building geometry"));
+  LOG(LINFO, ("Found", buildingInfo.m_buildingsIds.size(), "helpful addressless buildings"));
+  auto const buildingGeometries =
+      GetBuildingsGeometry(pathInGeoObjectsTmpMwm, buildingInfo, threadsCount);
+  LOG(LINFO, ("Saved", buildingGeometries.size(), "buildings geometries"));
+
+  size_t const pointsCount = AddBuildingGeometriesToAddressPoints(
+      pathInGeoObjectsTmpMwm, buildingInfo, buildingGeometries, threadsCount);
+
+  LOG(LINFO, (pointsCount, "address points were enriched with outer building geomery"));
+}
+
+template <class Activist>
+auto Measure(std::string activity, Activist && activist)
+{
+  LOG(LINFO, ("Start", activity));
+  auto timer = base::Timer();
+  SCOPE_GUARD(_, [&]() { LOG(LINFO, ("Finish", activity, timer.ElapsedSeconds(), "seconds.")); });
+
+  return activist();
+}
 }  // namespace
 
-bool GenerateGeoObjects(std::string const & pathInRegionsIndex, std::string const & pathInRegionsKv,
-                        std::string const & pathInGeoObjectsTmpMwm,
-                        std::string const & pathOutIdsWithoutAddress,
-                        std::string const & pathOutGeoObjectsKv,
-                        std::string const & allowAddresslessForCountries, bool verbose,
-                        size_t threadsCount)
+boost::optional<indexer::GeoObjectsIndex<IndexReader>> MakeTempGeoObjectsIndex(
+    std::string const & pathToGeoObjectsTmpMwm)
 {
-  LOG(LINFO, ("Start generating geo objects.."));
-  auto timer = base::Timer();
-  SCOPE_GUARD(finishGeneratingGeoObjects, [&timer]() {
-    LOG(LINFO, ("Finish generating geo objects.", timer.ElapsedSeconds(), "seconds."));
-  });
-
-  regions::RegionInfoGetter regionInfoGetter{pathInRegionsIndex, pathInRegionsKv};
-  LOG(LINFO, ("Size of regions key-value storage:", regionInfoGetter.GetStorage().Size()));
-
-  if (allowAddresslessForCountries != "*")
+  auto const dataFile = GetPlatform().TmpPathForFile();
+  SCOPE_GUARD(removeDataFile, std::bind(Platform::RemoveFileIfExists, std::cref(dataFile)));
+  if (!GenerateGeoObjectsData(pathToGeoObjectsTmpMwm, "" /* nodesFile */, dataFile))
   {
-    FilterAddresslessByCountryAndRepackMwm(pathInGeoObjectsTmpMwm, allowAddresslessForCountries,
-                                           regionInfoGetter, threadsCount);
-    LOG(LINFO,
-        ("Addressless buildings are filtered except countries", allowAddresslessForCountries, "."));
+    LOG(LCRITICAL, ("Error generating geo objects data."));
+    return {};
   }
 
-  auto geoObjectIndexFuture =
-      std::async(std::launch::async, MakeTempGeoObjectsIndex, pathInGeoObjectsTmpMwm);
+  auto const indexFile = GetPlatform().TmpPathForFile();
+  SCOPE_GUARD(removeIndexFile, std::bind(Platform::RemoveFileIfExists, std::cref(indexFile)));
+  if (!indexer::BuildGeoObjectsIndexFromDataFile(dataFile, indexFile))
+  {
+    LOG(LCRITICAL, ("Error generating geo objects index."));
+    return {};
+  }
+
+  return indexer::ReadIndex<indexer::GeoObjectsIndexBox<IndexReader>, MmapReader>(indexFile);
+}
+
+GeoObjectsGenerator::GeoObjectsGenerator(
+    std::string pathInRegionsIndex, std::string pathInRegionsKv, std::string pathInGeoObjectsTmpMwm,
+    std::string pathOutIdsWithoutAddress, std::string pathOutGeoObjectsKv,
+    std::string allowAddresslessForCountries, bool verbose, size_t threadsCount)
+
+  : m_pathInGeoObjectsTmpMwm(std::move(pathInGeoObjectsTmpMwm))
+  , m_pathOutIdsWithoutAddress(std::move(pathOutIdsWithoutAddress))
+  , m_pathOutGeoObjectsKv(std::move(pathOutGeoObjectsKv))
+  , m_allowAddresslessForCountries(std::move(allowAddresslessForCountries))
+  , m_verbose(verbose)
+  , m_threadsCount(threadsCount)
+  , m_geoObjectsKv(InitGeoObjectsKv(m_pathOutGeoObjectsKv))
+  , m_regionInfoGetter(pathInRegionsIndex, pathInRegionsKv)
+
+{
+}
+
+GeoObjectsGenerator::GeoObjectsGenerator(RegionInfoGetter && regionInfoGetter,
+                                         std::string pathInGeoObjectsTmpMwm,
+                                         std::string pathOutIdsWithoutAddress,
+                                         std::string pathOutGeoObjectsKv,
+                                         std::string allowAddresslessForCountries, bool verbose,
+                                         size_t threadsCount)
+  : m_pathInGeoObjectsTmpMwm(std::move(pathInGeoObjectsTmpMwm))
+  , m_pathOutIdsWithoutAddress(std::move(pathOutIdsWithoutAddress))
+  , m_pathOutGeoObjectsKv(std::move(pathOutGeoObjectsKv))
+  , m_allowAddresslessForCountries(std::move(allowAddresslessForCountries))
+  , m_verbose(verbose)
+  , m_threadsCount(threadsCount)
+  , m_geoObjectsKv(InitGeoObjectsKv(m_pathOutGeoObjectsKv))
+  , m_regionInfoGetter(std::move(regionInfoGetter))
+{
+}
+
+bool GeoObjectsGenerator::GenerateGeoObjects()
+{
+  return Measure("generating geo objects", [&]() { return GenerateGeoObjectsPrivate(); });
+}
+
+bool GeoObjectsGenerator::GenerateGeoObjectsPrivate()
+{
+  auto geoObjectIndexFuture =
+      std::async(std::launch::async, MakeTempGeoObjectsIndex, m_pathInGeoObjectsTmpMwm);
+
+  AddThingsWithHousesAndBuildingsAndEnrichWithRegionAddresses(
+      m_geoObjectsKv, m_regionInfoGetter, m_pathInGeoObjectsTmpMwm, m_verbose, m_threadsCount);
 
-  Platform().RemoveFileIfExists(pathOutGeoObjectsKv);
-  KeyValueStorage geoObjectsKv(pathOutGeoObjectsKv, 0 /* cacheValuesCountLimit */);
-  BuildGeoObjectsWithAddresses(geoObjectsKv, regionInfoGetter, pathInGeoObjectsTmpMwm, verbose,
-                               threadsCount);
   LOG(LINFO, ("Geo objects with addresses were built."));
 
   auto geoObjectIndex = geoObjectIndexFuture.get();
+
   LOG(LINFO, ("Index was built."));
   if (!geoObjectIndex)
     return false;
 
-  GeoObjectInfoGetter geoObjectInfoGetter{std::move(*geoObjectIndex), geoObjectsKv};
-  std::ofstream streamIdsWithoutAddress(pathOutIdsWithoutAddress);
-  BuildGeoObjectsWithoutAddresses(geoObjectsKv, geoObjectInfoGetter, pathInGeoObjectsTmpMwm,
-                                  streamIdsWithoutAddress, verbose, threadsCount);
+  GeoObjectInfoGetter const geoObjectInfoGetter{std::move(*geoObjectIndex), m_geoObjectsKv};
+
+  LOG(LINFO, ("Enrich address points with outer null building geometry."));
+
+  EnrichPointsWithOuterBuildingGeometry(geoObjectInfoGetter, m_pathInGeoObjectsTmpMwm,
+                                        m_threadsCount);
+
+  std::ofstream streamIdsWithoutAddress(m_pathOutIdsWithoutAddress);
+
+  AddPoisEnrichedWithHouseAddresses(m_geoObjectsKv, geoObjectInfoGetter, m_pathInGeoObjectsTmpMwm,
+                                    streamIdsWithoutAddress, m_verbose, m_threadsCount);
+
+  if (m_allowAddresslessForCountries != "*")
+  {
+    FilterAddresslessByCountryAndRepackMwm(m_pathInGeoObjectsTmpMwm, m_allowAddresslessForCountries,
+                                           m_regionInfoGetter, m_threadsCount);
+
+    LOG(LINFO, ("Addressless buildings are filtered except countries",
+                m_allowAddresslessForCountries, "."));
+  }
+
   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));
+  LOG(LINFO, ("Geo objects key-value storage saved to", m_pathOutGeoObjectsKv));
+  LOG(LINFO, ("Ids of POIs without addresses saved to", m_pathOutIdsWithoutAddress));
   return true;
 }
 }  // namespace geo_objects
diff --git a/generator/geo_objects/geo_objects.hpp b/generator/geo_objects/geo_objects.hpp
index 9e61bfd6d5..fdc6187179 100644
--- a/generator/geo_objects/geo_objects.hpp
+++ b/generator/geo_objects/geo_objects.hpp
@@ -1,25 +1,96 @@
 #pragma once
 
+#include "generator/key_value_storage.hpp"
+#include "generator/regions/region_info_getter.hpp"
+
+#include "geometry/meter.hpp"
+#include "geometry/point2d.hpp"
+
+#include "base/logging.hpp"
+#include "base/scope_guard.hpp"
+#include "base/timer.hpp"
+
+#include "platform/platform.hpp"
+
 #include <string>
 
 namespace generator
 {
 namespace geo_objects
 {
-// This function generates key-value pairs for geo objects.
-// First, we try to generate key-value pairs only for houses, since we cannot say anything about poi.
-// In this step, we need key-value pairs for the regions and the index for the regions.
-// Then we build an index for houses. And then we finish building key-value pairs for poi using
-// this index for houses.
-// |allowAddresslessForCountries| specifies countries for which addressless buldings are constructed
-// in index and key-value files. Countries are specified by osm's default local name (or part of name)
-// separated by commas. Default value is '*' (for all countries).
-bool GenerateGeoObjects(std::string const & pathInRegionsIndex,
-                        std::string const & pathInRegionsKv,
-                        std::string const & pathInGeoObjectsTmpMwm,
-                        std::string const & pathOutIdsWithoutAddress,
-                        std::string const & pathOutGeoObjectsKv,
-                        std::string const & allowAddresslessForCountries,
-                        bool verbose, size_t threadsCount);
+using IndexReader = ReaderPtr<Reader>;
+
+boost::optional<indexer::GeoObjectsIndex<IndexReader>> MakeTempGeoObjectsIndex(
+    std::string const & pathToGeoObjectsTmpMwm);
+
+class GeoObjectsGenerator
+{
+public:
+  using RegionInfoGetter = std::function<boost::optional<KeyValue>(m2::PointD const & pathPoint)>;
+
+  class RegionInfoGetterProxy
+  {
+  public:
+    RegionInfoGetterProxy(std::string const & pathInRegionsIndex,
+                          std::string const & pathInRegionsKv)
+    {
+      m_regionInfoGetter = regions::RegionInfoGetter(pathInRegionsIndex, pathInRegionsKv);
+      LOG(LINFO, ("Size of regions key-value storage:", m_regionInfoGetter->GetStorage().Size()));
+    }
+
+    explicit RegionInfoGetterProxy(RegionInfoGetter && regionInfoGetter)
+      : m_externalInfoGetter(std::move(regionInfoGetter))
+    {
+      LOG(LINFO, ("External regions info provided"));
+    }
+
+    boost::optional<KeyValue> FindDeepest(m2::PointD const & point) const
+    {
+      return m_regionInfoGetter ? m_regionInfoGetter->FindDeepest(point)
+                                : m_externalInfoGetter->operator()(point);
+    }
+
+  private:
+    boost::optional<regions::RegionInfoGetter> m_regionInfoGetter;
+    boost::optional<RegionInfoGetter> m_externalInfoGetter;
+  };
+
+  // |allowAddresslessForCountries| specifies countries for which addressless buldings are
+  // constructed in index and key-value files. Countries are specified by osm's default local name
+  // (or part of name) separated by commas. Default value is '*' (for all countries).
+  GeoObjectsGenerator(std::string pathInRegionsIndex, std::string pathInRegionsKv,
+                      std::string pathInGeoObjectsTmpMwm, std::string pathOutIdsWithoutAddress,
+                      std::string pathOutGeoObjectsKv, std::string allowAddresslessForCountries,
+                      bool verbose, size_t threadsCount);
+
+  GeoObjectsGenerator(RegionInfoGetter && regionInfoGetter, std::string pathInGeoObjectsTmpMwm,
+                      std::string pathOutIdsWithoutAddress, std::string pathOutGeoObjectsKv,
+                      std::string allowAddresslessForCountries, bool verbose, size_t threadsCount);
+
+  // This function generates key-value pairs for geo objects.
+  // First, we try to generate key-value pairs only for houses, since we cannot say anything about
+  // poi. In this step, we need key-value pairs for the regions and the index for the regions. Then
+  // we build an index for houses. And then we finish building key-value pairs for poi using this
+  // index for houses.
+  bool GenerateGeoObjects();
+
+private:
+  bool GenerateGeoObjectsPrivate();
+  static KeyValueStorage InitGeoObjectsKv(std::string const & pathOutGeoObjectsKv)
+  {
+    Platform().RemoveFileIfExists(pathOutGeoObjectsKv);
+    return KeyValueStorage(pathOutGeoObjectsKv, 0 /* cacheValuesCountLimit */);
+  }
+
+  std::string m_pathInGeoObjectsTmpMwm;
+  std::string m_pathOutIdsWithoutAddress;
+  std::string m_pathOutGeoObjectsKv;
+  std::string m_allowAddresslessForCountries;
+  bool m_verbose = false;
+  size_t m_threadsCount = 1;
+
+  KeyValueStorage m_geoObjectsKv;
+  RegionInfoGetterProxy m_regionInfoGetter;
+};
 }  // namespace geo_objects
 }  // namespace generator
diff --git a/generator/osm_source.hpp b/generator/osm_source.hpp
index 2c69a4da87..4c9f436058 100644
--- a/generator/osm_source.hpp
+++ b/generator/osm_source.hpp
@@ -63,7 +63,6 @@ private:
   DISALLOW_COPY(CacheLoader);
 };
 
-
 // This function is needed to generate intermediate data from OSM elements.
 // The translators collection contains translators that translate the OSM element into
 // some intermediate representation.
@@ -77,17 +76,18 @@ private:
 // 2. CacheLoader cacheLoader(genInfo);
 // 3. TranslatorCollection translators;
 // 4. auto emitter = CreateEmitter(EmitterType::Country, genInfo);
-// 5. translators.Append(CreateTranslator(TranslatorType::Country, emitter, cacheLoader.GetCache(), genInfo));
+// 5. translators.Append(CreateTranslator(TranslatorType::Country, emitter, cacheLoader.GetCache(),
+// genInfo));
 // 6. GenerateRaw(genInfo, translators);
 //
 // In line 5, we create and add a translator for countries to the translator collection.
 // TranslatorCountry is inheritor of Translator.
 //
-// Translator contains several important entities: FeatureMaker, FilterCollection, CollectorCollection
-// and Emitter. In short,
+// Translator contains several important entities: FeatureMaker, FilterCollection,
+// CollectorCollection and Emitter. In short,
 // * FeatureMaker - an object that can create FeatureBuilder1 from OSM element,
-// * FilterCollection - an object that contains a group of filters that may or may not pass OSM elements
-// and FeatureBuilder1s,
+// * FilterCollection - an object that contains a group of filters that may or may not pass OSM
+// elements and FeatureBuilder1s,
 // * CollectorCollection - an object that contains a group of collectors that collect additional
 // information about OSM elements and FeatureBuilder1s (most often it is information that cannot
 // be saved in FeatureBuilder1s from OSM element),
@@ -100,21 +100,18 @@ private:
 // CollectorCollection for the FeatureBuilder1, and then FeatureBuilder1 will fall into the emitter.
 //
 // TranslatorCountry contains for it specific filters, collectors, emitter and FeatureMaker.
-// For example, there are FilterPlanet, which only passes relations with types multipolygon or boundary,
-// and CameraNodeProcessor, which collects information about the cameras on the roads.
+// For example, there are FilterPlanet, which only passes relations with types multipolygon or
+// boundary, and CameraNodeProcessor, which collects information about the cameras on the roads.
 //
 // In line 4, we create emitter for countries.
-// The emitter is an important entity that needs to transform FeatureBuilder1 and save them in some way.
-// The emitter can filter objects and change the representation of an object based on drawing rules
-// and other application rules.
-// In EmitterCountry stages are divided into layers. The layers are connected in a chain.
-// For example, there are RepresentationLayer, which may change the presentation of the FeatureBuilder1
-// depending on the rules of the application, and BookingLayer, which mixes information from booking.
-// You can read a more detailed look into the appropriate class code.
+// The emitter is an important entity that needs to transform FeatureBuilder1 and save them in some
+// way. The emitter can filter objects and change the representation of an object based on drawing
+// rules and other application rules. In EmitterCountry stages are divided into layers. The layers
+// are connected in a chain. For example, there are RepresentationLayer, which may change the
+// presentation of the FeatureBuilder1 depending on the rules of the application, and BookingLayer,
+// which mixes information from booking. You can read a more detailed look into the appropriate
+// class code.
 bool GenerateRaw(feature::GenerateInfo & info, TranslatorInterface & translators);
-bool GenerateRegionFeatures(feature::GenerateInfo & info);
-bool GenerateGeoObjectsFeatures(feature::GenerateInfo & info);
-
 bool GenerateIntermediateData(feature::GenerateInfo & info);
 
 void ProcessOsmElementsFromO5M(SourceReader & stream, std::function<void(OsmElement *)> processor);
diff --git a/indexer/locality_index_builder.cpp b/indexer/locality_index_builder.cpp
index b10247378c..112148e133 100644
--- a/indexer/locality_index_builder.cpp
+++ b/indexer/locality_index_builder.cpp
@@ -72,7 +72,7 @@ bool BuildLocalityIndexFromDataFile(string const & dataFile,
       FileWriter writer(idxFileName);
 
       covering::BuildLocalityIndex<LocalityVector<ModelReaderPtr>, FileWriter, DEPTH_LEVELS>(
-          localities.GetVector(), writer, coverLocality, outFileName, IntervalIndexVersion::V1);
+          localities.GetVector(), writer, coverLocality, outFileName, IntervalIndexVersion::V2);
     }
 
     FilesContainerW(outFileName, FileWriter::OP_WRITE_TRUNCATE)