diff --git a/generator/affiliation.cpp b/generator/affiliation.cpp
index e54e6c9b76..4a779c1ad3 100644
--- a/generator/affiliation.cpp
+++ b/generator/affiliation.cpp
@@ -4,12 +4,10 @@
 
 #include "geometry/mercator.hpp"
 
-#include "base/assert.hpp"
 #include "base/thread_pool_computational.hpp"
 
 #include <cmath>
-#include <map>
-#include <utility>
+#include <functional>
 
 #include <boost/geometry.hpp>
 #include <boost/geometry/geometries/register/ring.hpp>
@@ -56,19 +54,31 @@ std::vector<std::string> CountriesFilesAffiliation::GetAffiliations(FeatureBuild
   return countries;
 }
 
-std::vector<bool>
-CountriesFilesAffiliation::GetFeaturePointsEntries(std::string const & mwmName,
-                                                   FeatureBuilder const & fb) const
+std::vector<std::string>
+CountriesFilesAffiliation::GetAffiliations(m2::PointD const & point) const
 {
-  std::vector<bool> entries;
-  entries.reserve(fb.GetPointsCount());
-  auto const & polygon = m_countries.GetRegionByName(mwmName);
-  fb.ForAnyGeometryPoint([&entries, &polygon](auto const & point) {
-    entries.emplace_back(polygon.Contains(point));
-    return false;
+  std::vector<std::string> countries;
+  std::vector<std::reference_wrapper<borders::CountryPolygons const>> countriesContainer;
+  m_countries.ForEachInRect(m2::RectD(point, point), [&](auto const & countryPolygons) {
+    countriesContainer.emplace_back(countryPolygons);
   });
 
-  return entries;
+  if (m_haveBordersForWholeWorld && countriesContainer.size() == 1)
+  {
+    borders::CountryPolygons const & countryPolygons = countriesContainer.front();
+    countries.emplace_back(countryPolygons.GetName());
+    return countries;
+  }
+
+  for (borders::CountryPolygons const & countryPolygons : countriesContainer)
+  {
+    auto const need = countryPolygons.Contains(point);
+
+    if (need)
+      countries.emplace_back(countryPolygons.GetName());
+  }
+
+  return countries;
 }
 
 bool CountriesFilesAffiliation::HasRegionByName(std::string const & name) const
@@ -250,10 +260,9 @@ bool SingleAffiliation::HasRegionByName(std::string const & name) const
   return name == m_filename;
 }
 
-std::vector<bool>
-SingleAffiliation::GetFeaturePointsEntries(std::string const & mwmName,
-                                           FeatureBuilder const & fb) const
+std::vector<std::string>
+SingleAffiliation::GetAffiliations(m2::PointD const & point) const
 {
-  UNREACHABLE();
+  return {m_filename};
 }
 }  // namespace feature
diff --git a/generator/affiliation.hpp b/generator/affiliation.hpp
index 8a187c289e..f18614fc79 100644
--- a/generator/affiliation.hpp
+++ b/generator/affiliation.hpp
@@ -19,9 +19,9 @@ public:
 
   // The method will return the names of the buckets to which the fb belongs.
   virtual std::vector<std::string> GetAffiliations(FeatureBuilder const & fb) const = 0;
+  virtual std::vector<std::string> GetAffiliations(m2::PointD const & point) const = 0;
   virtual bool HasRegionByName(std::string const & name) const = 0;
-  virtual std::vector<bool> GetFeaturePointsEntries(std::string const & mwmName,
-                                                    FeatureBuilder const & fb) const = 0;
+
 };
 
 class CountriesFilesAffiliation : public AffiliationInterface
@@ -31,9 +31,9 @@ public:
 
   // AffiliationInterface overrides:
   std::vector<std::string> GetAffiliations(FeatureBuilder const & fb) const override;
+  std::vector<std::string> GetAffiliations(m2::PointD const & point) const override;
+
   bool HasRegionByName(std::string const & name) const override;
-  std::vector<bool> GetFeaturePointsEntries(std::string const & mwmName,
-                                            FeatureBuilder const & fb) const override;
 
 protected:
   borders::CountriesContainer const & m_countries;
@@ -69,8 +69,7 @@ public:
   // AffiliationInterface overrides:
   std::vector<std::string> GetAffiliations(FeatureBuilder const &) const override;
   bool HasRegionByName(std::string const & name) const override;
-  std::vector<bool> GetFeaturePointsEntries(std::string const & mwmName,
-                                            FeatureBuilder const & fb) const override;
+  std::vector<std::string> GetAffiliations(m2::PointD const & point) const override;
 
 private:
   std::string m_filename;
diff --git a/generator/cross_mwm_osm_ways_collector.cpp b/generator/cross_mwm_osm_ways_collector.cpp
index 033f9528b2..5fab315a13 100644
--- a/generator/cross_mwm_osm_ways_collector.cpp
+++ b/generator/cross_mwm_osm_ways_collector.cpp
@@ -8,16 +8,17 @@
 #include "base/assert.hpp"
 #include "base/file_name_utils.hpp"
 
+#include <utility>
+
 namespace generator
 {
-
 // CrossMwmOsmWaysCollector ------------------------------------------------------------------------
 
-CrossMwmOsmWaysCollector::CrossMwmOsmWaysCollector(feature::GenerateInfo const & info)
-  : m_intermediateDir(info.m_intermediateDir)
+CrossMwmOsmWaysCollector::CrossMwmOsmWaysCollector(std::string intermediateDir,
+                                                   std::string const & targetDir,
+                                                   bool haveBordersForWholeWorld)
+  : m_intermediateDir(std::move(intermediateDir))
 {
-  auto const & targetDir = info.m_targetDir;
-  auto const haveBordersForWholeWorld = info.m_haveBordersForWholeWorld;
   m_affiliation =
       std::make_shared<feature::CountriesFilesAffiliation>(targetDir, haveBordersForWholeWorld);
 }
@@ -43,14 +44,28 @@ void CrossMwmOsmWaysCollector::CollectFeature(feature::FeatureBuilder const & fb
   if (!routing::IsRoad(fb.GetTypes()))
     return;
 
-  std::vector<std::string> affiliations = m_affiliation->GetAffiliations(fb);
+  auto const & affiliations = m_affiliation->GetAffiliations(fb);
   if (affiliations.size() == 1)
     return;
 
+  auto const & featurePoints = fb.GetOuterGeometry();
+
+  std::map<std::string, std::vector<bool>> featurePointsEntriesToMwm;
+  for (auto const & mwmName : affiliations)
+    featurePointsEntriesToMwm[mwmName] = std::vector<bool>(featurePoints.size(), false);
+
+  for (size_t pointNumber = 0; pointNumber < featurePoints.size(); ++pointNumber)
+  {
+    auto const & point = featurePoints[pointNumber];
+    auto const & pointAffiliations = m_affiliation->GetAffiliations(point);
+    for (auto const & mwmName : pointAffiliations)
+      featurePointsEntriesToMwm[mwmName][pointNumber] = true;
+  }
+
   for (auto const & mwmName : affiliations)
   {
-    std::vector<bool> entries = m_affiliation->GetFeaturePointsEntries(mwmName, fb);
-    std::vector<Info::SegmentInfo> crossMwmSegments;
+    auto const & entries = featurePointsEntriesToMwm[mwmName];
+    std::vector<CrossMwmInfo::SegmentInfo> crossMwmSegments;
     bool prevPointIn = entries[0];
     for (size_t i = 1; i < entries.size(); ++i)
     {
@@ -72,7 +87,7 @@ void CrossMwmOsmWaysCollector::CollectFeature(feature::FeatureBuilder const & fb
 void CrossMwmOsmWaysCollector::Save()
 {
   auto const & crossMwmOsmWaysDir = base::JoinPath(m_intermediateDir, CROSS_MWM_OSM_WAYS_DIR);
-  CHECK(Platform::MkDirChecked(crossMwmOsmWaysDir), ("Can not create dir:", crossMwmOsmWaysDir));
+  CHECK(Platform::MkDirChecked(crossMwmOsmWaysDir), (crossMwmOsmWaysDir));
 
   for (auto const & item : m_mwmToCrossMwmOsmIds)
   {
@@ -80,9 +95,11 @@ void CrossMwmOsmWaysCollector::Save()
     auto const & waysInfo = item.second;
 
     auto const & pathToCrossMwmOsmIds = base::JoinPath(crossMwmOsmWaysDir, mwmName);
-    std::ofstream output(pathToCrossMwmOsmIds);
+    std::ofstream output;
+    output.exceptions(std::fstream::failbit | std::fstream::badbit);
+    output.open(pathToCrossMwmOsmIds);
     for (auto const & wayInfo : waysInfo)
-      Info::Dump(wayInfo, output);
+      CrossMwmInfo::Dump(wayInfo, output);
   }
 }
 
@@ -99,44 +116,42 @@ void CrossMwmOsmWaysCollector::MergeInto(CrossMwmOsmWaysCollector & collector) c
     auto const & osmIds = item.second;
 
     auto & otherOsmIds = collector.m_mwmToCrossMwmOsmIds[mwmName];
-    otherOsmIds.insert(otherOsmIds.end(), osmIds.begin(), osmIds.end());
+    otherOsmIds.insert(otherOsmIds.end(), osmIds.cbegin(), osmIds.cend());
   }
 }
 
 // CrossMwmOsmWaysCollector::Info ------------------------------------------------------------------
 
-bool CrossMwmOsmWaysCollector::Info::operator<(Info const & rhs) const
+bool CrossMwmOsmWaysCollector::CrossMwmInfo::operator<(CrossMwmInfo const & rhs) const
 {
   return m_osmId < rhs.m_osmId;
 }
 
 // static
-void CrossMwmOsmWaysCollector::Info::Dump(Info const & info, std::ofstream & output)
+void CrossMwmOsmWaysCollector::CrossMwmInfo::Dump(CrossMwmInfo const & info, std::ofstream & output)
 {
-  {
-    output << base::MakeOsmWay(info.m_osmId) << " " << info.m_crossMwmSegments.size() << " ";
-    for (auto const & segmentInfo : info.m_crossMwmSegments)
-      output << segmentInfo.m_segmentId << " " << segmentInfo.m_forwardIsEnter << " ";
+  output << base::MakeOsmWay(info.m_osmId) << " " << info.m_crossMwmSegments.size() << " ";
+  for (auto const & segmentInfo : info.m_crossMwmSegments)
+    output << segmentInfo.m_segmentId << " " << segmentInfo.m_forwardIsEnter << " ";
 
-    output << std::endl;
-  }
+  output << std::endl;
 }
 
 // static
-std::set<CrossMwmOsmWaysCollector::Info>
-CrossMwmOsmWaysCollector::Info::LoadFromFileToSet(std::string const & path)
+std::set<CrossMwmOsmWaysCollector::CrossMwmInfo>
+CrossMwmOsmWaysCollector::CrossMwmInfo::LoadFromFileToSet(std::string const & path)
 {
-  std::set<Info> result;
-  std::ifstream input(path);
-  CHECK(input.good(), ("Can not open:", path));
+  std::set<CrossMwmInfo> result;
+  std::ifstream input;
+  input.exceptions(std::fstream::failbit | std::fstream::badbit);
+  input.open(path);
+  input.exceptions(std::fstream::badbit);
 
   uint64_t osmId;
   size_t segmentsNumber;
-  std::vector<SegmentInfo> segments;
-
   while (input >> osmId >> segmentsNumber)
   {
-    segments.clear();
+    std::vector<SegmentInfo> segments;
 
     CHECK_NOT_EQUAL(segmentsNumber, 0, ());
     segments.resize(segmentsNumber);
@@ -148,4 +163,4 @@ CrossMwmOsmWaysCollector::Info::LoadFromFileToSet(std::string const & path)
 
   return result;
 }
-}  // namespace generator
\ No newline at end of file
+}  // namespace generator
diff --git a/generator/cross_mwm_osm_ways_collector.hpp b/generator/cross_mwm_osm_ways_collector.hpp
index 4c4e8f9f5f..1b351f1aa1 100644
--- a/generator/cross_mwm_osm_ways_collector.hpp
+++ b/generator/cross_mwm_osm_ways_collector.hpp
@@ -9,18 +9,14 @@
 #include <map>
 #include <memory>
 #include <set>
+#include <string>
 
 namespace generator
 {
 class CrossMwmOsmWaysCollector : public generator::CollectorInterface
 {
 public:
-  explicit CrossMwmOsmWaysCollector(feature::GenerateInfo const & info);
-
-  explicit CrossMwmOsmWaysCollector(std::string intermediateDir,
-                                    std::shared_ptr<feature::CountriesFilesAffiliation> affiliation);
-
-  struct Info
+  struct CrossMwmInfo
   {
     struct SegmentInfo
     {
@@ -32,20 +28,25 @@ public:
       bool m_forwardIsEnter = false;
     };
 
-    bool operator<(Info const & rhs) const;
-
-    Info(uint64_t osmId, std::vector<SegmentInfo> crossMwmSegments)
+    explicit CrossMwmInfo(uint64_t osmId) : m_osmId(osmId) {}
+    CrossMwmInfo(uint64_t osmId, std::vector<SegmentInfo> crossMwmSegments)
         : m_osmId(osmId), m_crossMwmSegments(std::move(crossMwmSegments)) {}
 
-    explicit Info(uint64_t osmId) : m_osmId(osmId) {}
+    bool operator<(CrossMwmInfo const & rhs) const;
 
-    static void Dump(Info const & info, std::ofstream & output);
-    static std::set<Info> LoadFromFileToSet(std::string const & path);
+    static void Dump(CrossMwmInfo const & info, std::ofstream & output);
+    static std::set<CrossMwmInfo> LoadFromFileToSet(std::string const & path);
 
     uint64_t m_osmId;
     std::vector<SegmentInfo> m_crossMwmSegments;
   };
 
+  CrossMwmOsmWaysCollector(std::string intermediateDir,
+                           std::string const & targetDir,
+                           bool haveBordersForWholeWorld);
+  CrossMwmOsmWaysCollector(std::string intermediateDir,
+                           std::shared_ptr<feature::CountriesFilesAffiliation> affiliation);
+
   // generator::CollectorInterface overrides:
   // @{
   std::shared_ptr<CollectorInterface>
@@ -60,7 +61,7 @@ public:
 
 private:
   std::string m_intermediateDir;
-  std::map<std::string, std::vector<Info>> m_mwmToCrossMwmOsmIds;
+  std::map<std::string, std::vector<CrossMwmInfo>> m_mwmToCrossMwmOsmIds;
   std::shared_ptr<feature::CountriesFilesAffiliation> m_affiliation;
 };
 }  // namespace generator
diff --git a/generator/generator_tests/CMakeLists.txt b/generator/generator_tests/CMakeLists.txt
index 1b6fe7f8e5..84989484fc 100644
--- a/generator/generator_tests/CMakeLists.txt
+++ b/generator/generator_tests/CMakeLists.txt
@@ -15,6 +15,7 @@ set(
   collector_city_area_tests.cpp
   common.cpp
   common.hpp
+  cross_mwm_osm_ways_collector_tests.cpp
   descriptions_section_builder_tests.cpp
   feature_builder_test.cpp
   feature_merger_test.cpp
diff --git a/generator/generator_tests/cross_mwm_osm_ways_collector_tests.cpp b/generator/generator_tests/cross_mwm_osm_ways_collector_tests.cpp
new file mode 100644
index 0000000000..813a244cdc
--- /dev/null
+++ b/generator/generator_tests/cross_mwm_osm_ways_collector_tests.cpp
@@ -0,0 +1,174 @@
+#include "testing/testing.hpp"
+
+#include "generator/generator_tests/common.hpp"
+
+#include "generator/collector_collection.hpp"
+#include "generator/collector_tag.hpp"
+#include "generator/cross_mwm_osm_ways_collector.hpp"
+
+#include "platform/platform.hpp"
+
+#include "indexer/classificator_loader.cpp"
+
+#include "geometry/mercator.hpp"
+
+#include "base/assert.hpp"
+#include "base/macros.hpp"
+#include "base/scope_guard.hpp"
+
+#include <cstdint>
+#include <fstream>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+using namespace generator;
+using namespace generator_tests;
+
+namespace
+{
+std::string const kTmpDirName = "cross_mwm_ways";
+
+std::vector<std::string> const kHighwayUnclassifiedPath = {"highway", "unclassified"};
+std::vector<std::pair<std::string, std::string>> const kHighwayUnclassified = {
+    {"highway", "unclassified"}};
+
+std::string const kOsmWayIdOne = std::to_string(base::MakeOsmWay(1).GetEncodedId());
+std::string const kOsmWayIdTwo = std::to_string(base::MakeOsmWay(2).GetEncodedId());
+
+class CrossMwmWayCollectorTest
+{
+public:
+  CrossMwmWayCollectorTest()
+  {
+    classificator::Load();
+    m_targetDir = GetPlatform().WritableDir();
+
+    auto const & intermediateDir = base::JoinPath(m_targetDir, kTmpDirName);
+    UNUSED_VALUE(Platform::MkDir(intermediateDir));
+    m_intermediateDir = intermediateDir;
+  }
+
+  ~CrossMwmWayCollectorTest() { Platform::RmDirRecursively(m_intermediateDir); }
+
+  std::shared_ptr<CollectorCollection> InitCollection()
+  {
+    auto collection = std::make_shared<CollectorCollection>();
+    collection->Append(std::make_shared<CrossMwmOsmWaysCollector>(
+        m_intermediateDir, m_targetDir, true /* haveBordersForWholeWorld */));
+    return collection;
+  }
+
+  void Checker()
+  {
+    std::vector<std::string> answersForRomaniaNorth_West = {
+        /* osmId crossMwmSegmentsNumber [crossMwmSegmentsIds forwardIsEnter]+ */
+        kOsmWayIdOne + " 1 1 0 ", kOsmWayIdTwo + " 1 0 0 "};
+
+    std::vector<std::string> answersForHungary_Northern_Great_Plain = {
+        /* osmId crossMwmSegmentsNumber [crossMwmSegmentsIds forwardIsEnter]+ */
+        kOsmWayIdOne + " 1 1 1 ", kOsmWayIdTwo + " 1 0 1 "};
+
+    auto const & pathToRomania =
+        base::JoinPath(m_intermediateDir, CROSS_MWM_OSM_WAYS_DIR, "Romania_North_West");
+    auto const & pathToHungary =
+        base::JoinPath(m_intermediateDir, CROSS_MWM_OSM_WAYS_DIR, "Hungary_Northern Great Plain");
+
+    Check(pathToRomania, std::move(answersForRomaniaNorth_West));
+    Check(pathToHungary, std::move(answersForHungary_Northern_Great_Plain));
+  }
+
+private:
+  static void Check(std::string const & filename, std::vector<std::string> && answers)
+  {
+    std::ifstream stream;
+    stream.exceptions(std::ios::badbit);
+    stream.open(filename);
+    size_t pos = 0;
+    std::string line;
+    while (std::getline(stream, line))
+    {
+      TEST_EQUAL(line, answers[pos], ());
+      pos++;
+    }
+    TEST_EQUAL(pos, answers.size(), ());
+  }
+
+  std::string m_intermediateDir;
+  std::string m_targetDir;
+};
+
+feature::FeatureBuilder CreateFeatureBuilderFromOsmWay(uint64_t osmId,
+                                                       std::vector<m2::PointD> && points)
+{
+  feature::FeatureBuilder fb;
+  fb.AddOsmId(base::MakeOsmWay(osmId));
+  fb.SetLinear();
+  for (auto const & point : points)
+    fb.AddPoint(point);
+
+  fb.AddType(classif().GetTypeByPath(kHighwayUnclassifiedPath));
+  return fb;
+}
+
+void AddOsmWayByPoints(uint64_t osmId, std::vector<m2::PointD> && points,
+                       std::shared_ptr<CollectorInterface> const & collection)
+{
+  auto const & featureBuilder = CreateFeatureBuilderFromOsmWay(osmId, std::move(points));
+  collection->CollectFeature(
+      featureBuilder, MakeOsmElement(osmId, kHighwayUnclassified, OsmElement::EntityType::Way));
+}
+
+void AppendFirstWayFromRomaniaToHungary(std::shared_ptr<CollectorInterface> const & collection)
+{
+  {
+    // In "Romania_North_West", Out of "Hungary_Northern Great Plain"
+    auto const & a = MercatorBounds::FromLatLon({47.48897, 22.22737});
+    // In "Romania_North_West", Out of "Hungary_Northern Great Plain"
+    auto const & b = MercatorBounds::FromLatLon({47.52341, 22.24097});
+    // Out of "Romania_North_West", in "Hungary_Northern Great Plain"
+    auto const & c = MercatorBounds::FromLatLon({47.63462, 22.04041});
+    AddOsmWayByPoints(1 /* osmId */, {a, b, c} /* points */, collection);
+  }
+}
+
+void AppendSecondWayFromRomaniaToHungary(std::shared_ptr<CollectorInterface> const & collection)
+{
+  {
+    // In "Romania_North_West", Out of "Hungary_Northern Great Plain"
+    auto const & a = MercatorBounds::FromLatLon({47.36594, 22.16958});
+    // Out of "Romania_North_West", in "Hungary_Northern Great Plain"
+    auto const & b = MercatorBounds::FromLatLon({47.49356, 21.77018});
+    AddOsmWayByPoints(2 /* osmId */, {a, b} /* points */, collection);
+  }
+}
+
+UNIT_CLASS_TEST(CrossMwmWayCollectorTest, OneCollectorTest)
+{
+  auto collection1 = InitCollection();
+
+  AppendFirstWayFromRomaniaToHungary(collection1);
+  AppendSecondWayFromRomaniaToHungary(collection1);
+
+  collection1->Save();
+
+  Checker();
+}
+
+UNIT_CLASS_TEST(CrossMwmWayCollectorTest, TwoCollectorTest)
+{
+  auto collection1 = InitCollection();
+  AppendFirstWayFromRomaniaToHungary(collection1);
+
+  auto collection2 = collection1->Clone();
+  AppendSecondWayFromRomaniaToHungary(collection2);
+
+  collection1->Finish();
+  collection2->Finish();
+  collection1->Merge(*collection2);
+  collection1->Save();
+
+  Checker();
+}
+}  // namespace
diff --git a/generator/routing_index_generator.cpp b/generator/routing_index_generator.cpp
index 732d63e5b1..e3eb569521 100644
--- a/generator/routing_index_generator.cpp
+++ b/generator/routing_index_generator.cpp
@@ -264,7 +264,7 @@ void CalcCrossMwmTransitions(
 
   auto const & path = base::JoinPath(intermediateDir, CROSS_MWM_OSM_WAYS_DIR, country);
   auto const crossMwmOsmIdWays =
-      generator::CrossMwmOsmWaysCollector::Info::LoadFromFileToSet(path);
+      generator::CrossMwmOsmWaysCollector::CrossMwmInfo::LoadFromFileToSet(path);
 
   ForEachFromDat(mwmFile, [&](FeatureType & f, uint32_t featureId) {
     VehicleMask const roadMask = maskMaker.CalcRoadMask(f);
@@ -276,18 +276,16 @@ void CalcCrossMwmTransitions(
     auto const osmId = it->second;
     CHECK(osmId.GetType() == base::GeoObjectId::Type::ObsoleteOsmWay, ());
 
-    auto const it =
-        crossMwmOsmIdWays.find(generator::CrossMwmOsmWaysCollector::Info(osmId.GetEncodedId()));
+    auto const crossMwmWayInfoIt =
+        crossMwmOsmIdWays.find(generator::CrossMwmOsmWaysCollector::CrossMwmInfo(osmId.GetEncodedId()));
 
-    if (it != crossMwmOsmIdWays.cend())
+    if (crossMwmWayInfoIt != crossMwmOsmIdWays.cend())
     {
       f.ParseGeometry(FeatureType::BEST_GEOMETRY);
-      if (f.GetPointsCount() == 0)
-        return;
 
       VehicleMask const oneWayMask = maskMaker.CalcOneWayMask(f);
 
-      auto const & crossMwmWayInfo = *it;
+      auto const & crossMwmWayInfo = *crossMwmWayInfoIt;
       for (auto const & segmentInfo : crossMwmWayInfo.m_crossMwmSegments)
       {
         uint32_t const segmentId = segmentInfo.m_segmentId;
diff --git a/generator/translator_country.cpp b/generator/translator_country.cpp
index e95f6bf8c9..64c7477e72 100644
--- a/generator/translator_country.cpp
+++ b/generator/translator_country.cpp
@@ -98,11 +98,11 @@ TranslatorCountry::TranslatorCountry(std::shared_ptr<FeatureProcessorInterface>
   collectors->Append(std::make_shared<routing::RestrictionWriter>(info.GetIntermediateFileName(RESTRICTIONS_FILENAME), cache->GetCache()));
   collectors->Append(std::make_shared<routing::RoadAccessWriter>(info.GetIntermediateFileName(ROAD_ACCESS_FILENAME)));
   collectors->Append(std::make_shared<routing::CameraCollector>(info.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME)));
+  collectors->Append(std::make_shared<CrossMwmOsmWaysCollector>(info.m_intermediateDir, info.m_targetDir, info.m_haveBordersForWholeWorld));
   if (info.m_genAddresses)
     collectors->Append(std::make_shared<CollectorAddresses>(info.GetAddressesFileName()));
   if (!info.m_idToWikidataFilename.empty())
     collectors->Append(std::make_shared<CollectorTag>(info.m_idToWikidataFilename, "wikidata" /* tagKey */, WikiDataValidator));
-  collectors->Append(std::make_shared<CrossMwmOsmWaysCollector>(info));
   SetCollector(collectors);
 }
 
diff --git a/routing/cross_mwm_connector_serialization.hpp b/routing/cross_mwm_connector_serialization.hpp
index 9fae407c9d..965eb02729 100644
--- a/routing/cross_mwm_connector_serialization.hpp
+++ b/routing/cross_mwm_connector_serialization.hpp
@@ -91,7 +91,7 @@ public:
     template <class Sink>
     void Serialize(uint32_t bitsPerCrossMwmId, uint8_t bitsPerMask, Sink & sink) const
     {
-      // TODO (@gmoryes)
+      // TODO (@gmoryes):
       //  We do not use back and front point of segment in code, so we just write
       //  zero to this 128 bits. Need to remove this data from mwm section.
       WriteVarUint<uint64_t>(sink, 0);
diff --git a/routing/index_router.cpp b/routing/index_router.cpp
index d690df972e..370dd7794a 100644
--- a/routing/index_router.cpp
+++ b/routing/index_router.cpp
@@ -557,7 +557,7 @@ RouterResultCode IndexRouter::CalculateSubroute(Checkpoints const & checkpoints,
       starter.GetGraph().SetMode(WorldGraphMode::Joints);
       break;
     case VehicleType::Transit:
-      starter.GetGraph().SetMode(WorldGraphMode::Joints);
+      starter.GetGraph().SetMode(WorldGraphMode::NoLeaps);
       break;
     case VehicleType::Car:
       starter.GetGraph().SetMode(AreMwmsNear(starter) ? WorldGraphMode::Joints