diff --git a/transit/world_feed/CMakeLists.txt b/transit/world_feed/CMakeLists.txt
index f6bd1fe097..c2e3d890c2 100644
--- a/transit/world_feed/CMakeLists.txt
+++ b/transit/world_feed/CMakeLists.txt
@@ -15,6 +15,7 @@ omim_add_library(${PROJECT_NAME} ${SRC})
 
 omim_link_libraries(
     ${PROJECT_NAME}
+    generator
     drape_frontend
     shaders
     routing
diff --git a/transit/world_feed/gtfs_converter/gtfs_converter.cpp b/transit/world_feed/gtfs_converter/gtfs_converter.cpp
index a62300a875..d5f555bd25 100644
--- a/transit/world_feed/gtfs_converter/gtfs_converter.cpp
+++ b/transit/world_feed/gtfs_converter/gtfs_converter.cpp
@@ -1,3 +1,5 @@
+#include "generator/affiliation.hpp"
+
 #include "transit/world_feed/color_picker.hpp"
 #include "transit/world_feed/world_feed.hpp"
 
@@ -198,6 +200,9 @@ int main(int argc, char ** argv)
   GetPlatform().SetResourceDir(FLAGS_path_resources);
   transit::ColorPicker colorPicker;
 
+  feature::CountriesFilesAffiliation mwmMatcher(GetPlatform().ResourcesDir(),
+                                                false /* haveBordersForWholeWorld */);
+
   for (size_t i = 0; i < gtfsFeeds.size(); ++i)
   {
     base::Timer feedTimer;
@@ -231,7 +236,7 @@ int main(int argc, char ** argv)
       continue;
     }
 
-    transit::WorldFeed globalFeed(generator, colorPicker);
+    transit::WorldFeed globalFeed(generator, colorPicker, mwmMatcher);
 
     if (!globalFeed.SetFeed(std::move(feed)))
     {
diff --git a/transit/world_feed/world_feed.cpp b/transit/world_feed/world_feed.cpp
index f41bc9b554..c84f7acb42 100644
--- a/transit/world_feed/world_feed.cpp
+++ b/transit/world_feed/world_feed.cpp
@@ -17,7 +17,6 @@
 #include "base/newtype.hpp"
 
 #include <algorithm>
-#include <fstream>
 #include <iosfwd>
 #include <memory>
 #include <tuple>
@@ -47,6 +46,37 @@ auto BuildHash(Values... values)
   return hash;
 }
 
+template <class C, class ID>
+void AddToRegions(C & container, ID const & id, transit::Regions const & regions)
+{
+  for (auto const & region : regions)
+    container[region].emplace(id);
+}
+
+template <class C, class ID, class S>
+transit::Regions AddToRegions(C & container, S const & splitter, ID const & id,
+                              m2::PointD const & point)
+{
+  auto const & regions = splitter.GetAffiliations(point);
+  CHECK_LESS_OR_EQUAL(
+      regions.size(), 1,
+      ("Point", mercator::ToLatLon(point), "belongs to multiple regions:", regions));
+
+  AddToRegions(container, id, regions);
+  return regions;
+}
+
+template <class C>
+void AddToRegionsIfMatches(C & container, transit::TransitId idForAdd,
+                           transit::IdsInRegion const & stopsInRegion, transit::TransitId stopId)
+{
+  for (auto const & [region, stopIds] : stopsInRegion)
+  {
+    if (stopIds.find(stopId) != stopIds.end())
+      container[region].emplace(idForAdd);
+  }
+}
+
 void WriteJson(json_t * node, std::ofstream & output)
 {
   std::unique_ptr<char, JSONFreeDeleter> buffer(json_dumps(node, JSON_COMPACT));
@@ -99,8 +129,8 @@ base::JSONPtr TranslationsToJson(transit::Translations const & translations)
   return translationsArr;
 }
 
-template <class T>
-bool DumpData(T const & container, std::string const & path, bool overwrite)
+template <class C, class S>
+bool DumpData(C const & container, S const & idSet, std::string const & path, bool overwrite)
 {
   std::ofstream output;
   output.exceptions(std::ofstream::failbit | std::ofstream::badbit);
@@ -113,7 +143,7 @@ bool DumpData(T const & container, std::string const & path, bool overwrite)
     if (!output.is_open())
       return false;
 
-    container.Write(output);
+    container.Write(idSet, output);
   }
   catch (std::ofstream::failure const & se)
   {
@@ -195,6 +225,15 @@ bool EdgeId::operator==(EdgeId const & other) const
          std::tie(other.m_fromStopId, other.m_toStopId, other.m_lineId);
 }
 
+EdgeTransferId::EdgeTransferId(TransitId fromStopId, TransitId toStopId)
+  : m_fromStopId(fromStopId), m_toStopId(toStopId)
+{
+}
+
+bool EdgeTransferId::operator==(EdgeTransferId const & other) const
+{
+  return std::tie(m_fromStopId, m_toStopId) == std::tie(other.m_fromStopId, other.m_toStopId);
+}
 size_t EdgeIdHasher::operator()(EdgeId const & key) const
 {
   size_t seed = 0;
@@ -204,9 +243,12 @@ size_t EdgeIdHasher::operator()(EdgeId const & key) const
   return seed;
 }
 
-bool operator<(EdgeTransferData const & d1, EdgeTransferData const & d2)
+size_t EdgeTransferIdHasher::operator()(EdgeTransferId const & key) const
 {
-  return std::tie(d1.m_fromStopId, d1.m_toStopId) < std::tie(d2.m_fromStopId, d2.m_toStopId);
+  size_t seed = 0;
+  boost::hash_combine(seed, key.m_fromStopId);
+  boost::hash_combine(seed, key.m_toStopId);
+  return seed;
 }
 
 ShapeData::ShapeData(std::vector<m2::PointD> const & points) : m_points(points) {}
@@ -335,8 +377,9 @@ void StopData::UpdateTimetable(TransitId lineId, gtfs::StopTime const & stopTime
   it->second = osmoh::OpeningHours({ruleSeq});
 }
 
-WorldFeed::WorldFeed(IdGenerator & generator, ColorPicker & colorPicker)
-  : m_idGenerator(generator), m_colorPicker(colorPicker)
+WorldFeed::WorldFeed(IdGenerator & generator, ColorPicker & colorPicker,
+                     feature::CountriesFilesAffiliation & mwmMatcher)
+  : m_idGenerator(generator), m_colorPicker(colorPicker), m_affiliation(mwmMatcher)
 {
 }
 
@@ -672,7 +715,7 @@ void WorldFeed::ModifyLinesAndShapes()
   size_t subShapesCount = 0;
 
   // Shape ids of shapes fully contained in other shapes.
-  std::unordered_set<TransitId> shapesForRemoval;
+  IdSet shapesForRemoval;
 
   // Shape id matching to the line id linked to this shape id.
   std::unordered_map<TransitId, TransitId> matchingCache;
@@ -1018,14 +1061,11 @@ void WorldFeed::FillTransfers()
     std::tie(std::ignore, inserted) = m_transfers.m_data.emplace(transitId, data);
     if (inserted)
     {
-      EdgeTransferData edgeData;
-      edgeData.m_fromStopId = stop1Id;
-      edgeData.m_toStopId = stop2Id;
-      edgeData.m_weight = transfer.min_transfer_time;  // Can be 0.
-
-      std::tie(std::ignore, inserted) = m_edgesTransfers.m_data.insert(edgeData);
+      EdgeTransferId const transferId(stop1Id, stop2Id);
+      std::tie(std::ignore, inserted) =
+          m_edgesTransfers.m_data.emplace(transferId, transfer.min_transfer_time);
       if (!inserted)
-        LOG(LINFO, ("Transfers copy", transfer.from_stop_id, transfer.to_stop_id));
+        LOG(LWARNING, ("Transfers copy", transfer.from_stop_id, transfer.to_stop_id));
     }
   }
 }
@@ -1141,12 +1181,13 @@ bool WorldFeed::SetFeed(gtfs::Feed && feed)
   return true;
 }
 
-void Networks::Write(std::ofstream & stream) const
+void Networks::Write(IdSet const & ids, std::ofstream & stream) const
 {
-  for (auto const & [networkId, networkTitle] : m_data)
+  for (auto networkId : ids)
   {
-    auto node = base::NewJSONObject();
+    auto const & networkTitle = m_data.find(networkId)->second;
 
+    auto node = base::NewJSONObject();
     ToJSONObject(*node, "id", networkId);
     json_object_set_new(node.get(), "title", TranslationsToJson(networkTitle).release());
 
@@ -1154,10 +1195,11 @@ void Networks::Write(std::ofstream & stream) const
   }
 }
 
-void Routes::Write(std::ofstream & stream) const
+void Routes::Write(IdSet const & ids, std::ofstream & stream) const
 {
-  for (auto const & [routeId, route] : m_data)
+  for (auto routeId : ids)
   {
+    auto const & route = m_data.find(routeId)->second;
     auto node = base::NewJSONObject();
     ToJSONObject(*node, "id", routeId);
     ToJSONObject(*node, "network_id", route.m_networkId);
@@ -1169,17 +1211,19 @@ void Routes::Write(std::ofstream & stream) const
   }
 }
 
-void Lines::Write(std::ofstream & stream) const
+void Lines::Write(std::unordered_map<TransitId, IdList> const & ids, std::ofstream & stream) const
 {
-  for (auto const & [lineId, line] : m_data)
+  for (auto const & [lineId, stopIds] : ids)
   {
+    auto const & line = m_data.find(lineId)->second;
     auto node = base::NewJSONObject();
     ToJSONObject(*node, "id", lineId);
     ToJSONObject(*node, "route_id", line.m_routeId);
     json_object_set_new(node.get(), "shape", ShapeLinkToJson(line.m_shapeLink).release());
 
     json_object_set_new(node.get(), "title", TranslationsToJson(line.m_title).release());
-    json_object_set_new(node.get(), "stops_ids", StopIdsToJson(line.m_stopIds).release());
+    // Save only stop ids inside current region.
+    json_object_set_new(node.get(), "stops_ids", StopIdsToJson(stopIds).release());
     ToJSONObject(*node, "service_days", ToString(line.m_serviceDays));
 
     auto intervalsArr = base::NewJSONArray();
@@ -1198,10 +1242,11 @@ void Lines::Write(std::ofstream & stream) const
   }
 }
 
-void Shapes::Write(std::ofstream & stream) const
+void Shapes::Write(IdSet const & ids, std::ofstream & stream) const
 {
-  for (auto const & [shapeId, shape] : m_data)
+  for (auto shapeId : ids)
   {
+    auto const & shape = m_data.find(shapeId)->second;
     auto node = base::NewJSONObject();
     ToJSONObject(*node, "id", shapeId);
     auto pointsArr = base::NewJSONArray();
@@ -1215,13 +1260,13 @@ void Shapes::Write(std::ofstream & stream) const
   }
 }
 
-void Stops::Write(std::ofstream & stream) const
+void Stops::Write(IdSet const & ids, std::ofstream & stream) const
 {
-  for (auto const & [stopId, stop] : m_data)
+  for (auto stopId : ids)
   {
+    auto const & stop = m_data.find(stopId)->second;
     auto node = base::NewJSONObject();
     ToJSONObject(*node, "id", stopId);
-
     json_object_set_new(node.get(), "point", PointToJson(stop.m_point).release());
     json_object_set_new(node.get(), "title", TranslationsToJson(stop.m_title).release());
 
@@ -1240,12 +1285,12 @@ void Stops::Write(std::ofstream & stream) const
   }
 }
 
-void Edges::Write(std::ofstream & stream) const
+void Edges::Write(IdEdgeSet const & ids, std::ofstream & stream) const
 {
-  for (auto const & [edgeId, edge] : m_data)
+  for (auto const & edgeId : ids)
   {
+    auto const & edge = m_data.find(edgeId)->second;
     auto node = base::NewJSONObject();
-
     ToJSONObject(*node, "line_id", edgeId.m_lineId);
     ToJSONObject(*node, "stop_id_from", edgeId.m_fromStopId);
     ToJSONObject(*node, "stop_id_to", edgeId.m_toStopId);
@@ -1256,26 +1301,28 @@ void Edges::Write(std::ofstream & stream) const
   }
 }
 
-void EdgesTransfer::Write(std::ofstream & stream) const
+void EdgesTransfer::Write(IdEdgeTransferSet const & ids, std::ofstream & stream) const
 {
-  for (auto const & edge : m_data)
+  for (auto const & edgeTransferId : ids)
   {
+    auto const weight = m_data.find(edgeTransferId)->second;
     auto node = base::NewJSONObject();
 
-    ToJSONObject(*node, "stop_id_from", edge.m_fromStopId);
-    ToJSONObject(*node, "stop_id_to", edge.m_toStopId);
-    ToJSONObject(*node, "weight", edge.m_weight);
+    ToJSONObject(*node, "stop_id_from", edgeTransferId.m_fromStopId);
+    ToJSONObject(*node, "stop_id_to", edgeTransferId.m_toStopId);
+    ToJSONObject(*node, "weight", weight);
 
     WriteJson(node.get(), stream);
   }
 }
 
-void Transfers::Write(std::ofstream & stream) const
+void Transfers::Write(IdSet const & ids, std::ofstream & stream) const
 {
-  for (auto const & [transferId, transfer] : m_data)
+  for (auto transferId : ids)
   {
-    auto node = base::NewJSONObject();
+    auto const & transfer = m_data.find(transferId)->second;
 
+    auto node = base::NewJSONObject();
     ToJSONObject(*node, "id", transferId);
     json_object_set_new(node.get(), "point", PointToJson(transfer.m_point).release());
     json_object_set_new(node.get(), "stops_ids", StopIdsToJson(transfer.m_stopsIds).release());
@@ -1284,10 +1331,11 @@ void Transfers::Write(std::ofstream & stream) const
   }
 }
 
-void Gates::Write(std::ofstream & stream) const
+void Gates::Write(IdSet const & ids, std::ofstream & stream) const
 {
-  for (auto const & [gateId, gate] : m_data)
+  for (auto gateId : ids)
   {
+    auto const & gate = m_data.find(gateId)->second;
     if (gate.m_weights.empty())
       continue;
 
@@ -1314,6 +1362,119 @@ void Gates::Write(std::ofstream & stream) const
   }
 }
 
+void WorldFeed::SplitFeedIntoRegions()
+{
+  SplitStopsBasedData();
+  LOG(LINFO, ("Split stops into", m_splitting.m_stops.size(), "regions."));
+  SplitLinesBasedData();
+  SplitSupplementalData();
+}
+
+void WorldFeed::SplitStopsBasedData()
+{
+  // Fill regional stops from edges.
+  for (auto const & [edgeId, data] : m_edges.m_data)
+  {
+    auto const [regFrom, regTo] = ExtendRegionsByPair(edgeId.m_fromStopId, edgeId.m_toStopId);
+    AddToRegions(m_splitting.m_edges, edgeId, regFrom);
+    AddToRegions(m_splitting.m_edges, edgeId, regTo);
+  }
+
+  // Fill regional stops from transfer edges.
+  for (auto const & [edgeTransferId, data] : m_edgesTransfers.m_data)
+  {
+    auto const [regFrom, regTo] =
+        ExtendRegionsByPair(edgeTransferId.m_fromStopId, edgeTransferId.m_toStopId);
+    AddToRegions(m_splitting.m_edgesTransfers, edgeTransferId, regFrom);
+    AddToRegions(m_splitting.m_edgesTransfers, edgeTransferId, regTo);
+  }
+}
+
+void WorldFeed::SplitLinesBasedData()
+{
+  // Fill regional lines and corresponding shapes and routes.
+  for (auto const & [lineId, lineData] : m_lines.m_data)
+  {
+    for (auto stopId : lineData.m_stopIds)
+    {
+      for (auto const & [region, stopIds] : m_splitting.m_stops)
+      {
+        if (stopIds.find(stopId) == stopIds.end())
+          continue;
+
+        m_splitting.m_lines[region][lineId].emplace_back(stopId);
+        m_splitting.m_shapes[region].emplace(lineData.m_shapeLink.m_shapeId);
+        m_splitting.m_routes[region].emplace(lineData.m_routeId);
+      }
+    }
+  }
+
+  // Fill regional networks based on routes.
+  for (auto const & [region, routeIds] : m_splitting.m_routes)
+  {
+    for (auto routeId : routeIds)
+      m_splitting.m_networks[region].emplace(m_routes.m_data[routeId].m_networkId);
+  }
+}
+
+void WorldFeed::SplitSupplementalData()
+{
+  for (auto const & [gateId, gateData] : m_gates.m_data)
+  {
+    for (auto const & weight : gateData.m_weights)
+      AddToRegionsIfMatches(m_splitting.m_gates, gateId, m_splitting.m_stops, weight.m_stopId);
+  }
+
+  for (auto const & [transferId, transferData] : m_transfers.m_data)
+  {
+    for (auto const & stopId : transferData.m_stopsIds)
+      AddToRegionsIfMatches(m_splitting.m_transfers, transferId, m_splitting.m_stops, stopId);
+  }
+}
+
+std::pair<Regions, Regions> WorldFeed::ExtendRegionsByPair(TransitId fromId, TransitId toId)
+{
+  auto const & pointFrom = m_stops.m_data[fromId].m_point;
+  auto const & pointTo = m_stops.m_data[toId].m_point;
+  auto const regionsFrom = AddToRegions(m_splitting.m_stops, m_affiliation, fromId, pointFrom);
+  auto const regionsTo = AddToRegions(m_splitting.m_stops, m_affiliation, toId, pointTo);
+
+  AddToRegions(m_splitting.m_stops, toId, regionsFrom);
+  AddToRegions(m_splitting.m_stops, fromId, regionsTo);
+  return {regionsFrom, regionsTo};
+}
+
+void WorldFeed::SaveRegions(std::string const & worldFeedDir, std::string const & region,
+                            bool overwrite)
+{
+  auto const path = base::JoinPath(worldFeedDir, region);
+  CHECK(Platform::MkDirRecursively(path), (path));
+
+  CHECK(DumpData(m_networks, m_splitting.m_networks[region], base::JoinPath(path, kNetworksFile),
+                 overwrite),
+        ());
+  CHECK(DumpData(m_routes, m_splitting.m_routes[region], base::JoinPath(path, kRoutesFile),
+                 overwrite),
+        ());
+  CHECK(DumpData(m_lines, m_splitting.m_lines[region], base::JoinPath(path, kLinesFile), overwrite),
+        ());
+  CHECK(DumpData(m_shapes, m_splitting.m_shapes[region], base::JoinPath(path, kShapesFile),
+                 overwrite),
+        ());
+  CHECK(DumpData(m_stops, m_splitting.m_stops[region], base::JoinPath(path, kStopsFile), overwrite),
+        ());
+  CHECK(DumpData(m_edges, m_splitting.m_edges[region], base::JoinPath(path, kEdgesFile), overwrite),
+        ());
+  CHECK(DumpData(m_edgesTransfers, m_splitting.m_edgesTransfers[region],
+                 base::JoinPath(path, kEdgesTransferFile), overwrite),
+        ());
+  CHECK(DumpData(m_transfers, m_splitting.m_transfers[region], base::JoinPath(path, kTransfersFile),
+                 overwrite),
+        ());
+  CHECK(DumpData(m_gates, m_splitting.m_gates[region], base::JoinPath(path, kGatesFile), overwrite),
+        ());
+}
+
 bool WorldFeed::Save(std::string const & worldFeedDir, bool overwrite)
 {
   CHECK(!worldFeedDir.empty(), ());
@@ -1328,17 +1489,12 @@ bool WorldFeed::Save(std::string const & worldFeedDir, bool overwrite)
   }
 
   CHECK(!m_edges.m_data.empty(), ());
-  LOG(LINFO, ("Saving feed to", worldFeedDir));
-  CHECK(DumpData(m_networks, base::JoinPath(worldFeedDir, kNetworksFile), overwrite), ());
-  CHECK(DumpData(m_routes, base::JoinPath(worldFeedDir, kRoutesFile), overwrite), ());
-  CHECK(DumpData(m_lines, base::JoinPath(worldFeedDir, kLinesFile), overwrite), ());
-  CHECK(DumpData(m_shapes, base::JoinPath(worldFeedDir, kShapesFile), overwrite), ());
-  CHECK(DumpData(m_stops, base::JoinPath(worldFeedDir, kStopsFile), overwrite), ());
-  CHECK(DumpData(m_edges, base::JoinPath(worldFeedDir, kEdgesFile), overwrite), ());
-  CHECK(DumpData(m_edgesTransfers, base::JoinPath(worldFeedDir, kEdgesTransferFile), overwrite),
-        ());
-  CHECK(DumpData(m_transfers, base::JoinPath(worldFeedDir, kTransfersFile), overwrite), ());
-  CHECK(DumpData(m_gates, base::JoinPath(worldFeedDir, kGatesFile), overwrite), ());
+  LOG(LINFO, ("Started splitting feed into regions."));
+  SplitFeedIntoRegions();
+  LOG(LINFO, ("Finished splitting feed into regions. Saving to", worldFeedDir));
+
+  for (auto const & regionAndData : m_splitting.m_stops)
+    SaveRegions(worldFeedDir, regionAndData.first, overwrite);
 
   return true;
 }
diff --git a/transit/world_feed/world_feed.hpp b/transit/world_feed/world_feed.hpp
index d7839bd24a..0b4561fdad 100644
--- a/transit/world_feed/world_feed.hpp
+++ b/transit/world_feed/world_feed.hpp
@@ -1,22 +1,24 @@
 #pragma once
+#include "generator/affiliation.hpp"
+
 #include "transit/world_feed/color_picker.hpp"
 
 #include "geometry/mercator.hpp"
 #include "geometry/point2d.hpp"
 
+#include "defines.hpp"
+
 #include <cstdint>
 #include <fstream>
-#include <set>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
+#include <utility>
 #include <vector>
 
 #include "3party/just_gtfs/just_gtfs.h"
 #include "3party/opening_hours/opening_hours.hpp"
 
-#include "defines.hpp"
-
 namespace transit
 {
 // File names for saving resulting data exported from GTFS.
@@ -56,12 +58,14 @@ private:
 // Here are MAPS.ME representations for GTFS entities, e.g. networks for GTFS agencies.
 // https://developers.google.com/transit/gtfs/reference
 
+using IdSet = std::unordered_set<TransitId>;
+
 // Mapping of language id to text.
 using Translations = std::unordered_map<std::string, std::string>;
 
 struct Networks
 {
-  void Write(std::ofstream & stream) const;
+  void Write(IdSet const & ids, std::ofstream & stream) const;
 
   // Id to agency name mapping.
   std::unordered_map<TransitId, Translations> m_data;
@@ -77,7 +81,7 @@ struct RouteData
 
 struct Routes
 {
-  void Write(std::ofstream & stream) const;
+  void Write(IdSet const & ids, std::ofstream & stream) const;
 
   std::unordered_map<TransitId, RouteData> m_data;
 };
@@ -121,7 +125,7 @@ struct LineData
 
 struct Lines
 {
-  void Write(std::ofstream & stream) const;
+  void Write(std::unordered_map<TransitId, IdList> const & ids, std::ofstream & stream) const;
 
   std::unordered_map<TransitId, LineData> m_data;
 };
@@ -133,12 +137,12 @@ struct ShapeData
 
   std::vector<m2::PointD> m_points;
   // Field not for dumping to json:
-  std::unordered_set<TransitId> m_lineIds;
+  IdSet m_lineIds;
 };
 
 struct Shapes
 {
-  void Write(std::ofstream & stream) const;
+  void Write(IdSet const & ids, std::ofstream & stream) const;
 
   std::unordered_map<TransitId, ShapeData> m_data;
 };
@@ -158,7 +162,7 @@ struct StopData
 
 struct Stops
 {
-  void Write(std::ofstream & stream) const;
+  void Write(IdSet const & ids, std::ofstream & stream) const;
 
   std::unordered_map<TransitId, StopData> m_data;
 };
@@ -180,6 +184,8 @@ struct EdgeIdHasher
   size_t operator()(EdgeId const & key) const;
 };
 
+using IdEdgeSet = std::unordered_set<EdgeId, EdgeIdHasher>;
+
 struct EdgeData
 {
   ShapeLink m_shapeLink;
@@ -188,25 +194,34 @@ struct EdgeData
 
 struct Edges
 {
-  void Write(std::ofstream & stream) const;
+  void Write(IdEdgeSet const & ids, std::ofstream & stream) const;
 
   std::unordered_map<EdgeId, EdgeData, EdgeIdHasher> m_data;
 };
 
-struct EdgeTransferData
+struct EdgeTransferId
 {
+  EdgeTransferId() = default;
+  EdgeTransferId(TransitId fromStopId, TransitId toStopId);
+
+  bool operator==(EdgeTransferId const & other) const;
+
   TransitId m_fromStopId = 0;
   TransitId m_toStopId = 0;
-  size_t m_weight = 0;
 };
 
-bool operator<(EdgeTransferData const & d1, EdgeTransferData const & d2);
+struct EdgeTransferIdHasher
+{
+  size_t operator()(EdgeTransferId const & key) const;
+};
+
+using IdEdgeTransferSet = std::unordered_set<EdgeTransferId, EdgeTransferIdHasher>;
 
 struct EdgesTransfer
 {
-  void Write(std::ofstream & stream) const;
-
-  std::set<EdgeTransferData> m_data;
+  void Write(IdEdgeTransferSet const & ids, std::ofstream & stream) const;
+  // Key is pair of stops and value is weight (in seconds).
+  std::unordered_map<EdgeTransferId, size_t, EdgeTransferIdHasher> m_data;
 };
 
 struct TransferData
@@ -217,7 +232,7 @@ struct TransferData
 
 struct Transfers
 {
-  void Write(std::ofstream & stream) const;
+  void Write(IdSet const & ids, std::ofstream & stream) const;
 
   std::unordered_map<TransitId, TransferData> m_data;
 };
@@ -241,7 +256,7 @@ struct GateData
 
 struct Gates
 {
-  void Write(std::ofstream & stream) const;
+  void Write(IdSet const & ids, std::ofstream & stream) const;
 
   std::unordered_map<TransitId, GateData> m_data;
 };
@@ -266,15 +281,42 @@ struct StopsOnLines
   explicit StopsOnLines(IdList const & ids);
 
   IdList m_stopSeq;
-  std::unordered_set<TransitId> m_lines;
+  IdSet m_lines;
   bool m_isValid = true;
 };
 
+using IdsInRegion = std::unordered_map<std::string, IdSet>;
+using LineIdsInRegion = std::unordered_map<std::string, std::unordered_map<TransitId, IdList>>;
+using EdgeIdsInRegion = std::unordered_map<std::string, IdEdgeSet>;
+using EdgeTransferIdsInRegion = std::unordered_map<std::string, IdEdgeTransferSet>;
+
+using Regions = std::vector<std::string>;
+
+struct TransitByRegion
+{
+  IdsInRegion m_networks;
+  IdsInRegion m_routes;
+  LineIdsInRegion m_lines;
+  IdsInRegion m_shapes;
+  IdsInRegion m_stops;
+  EdgeIdsInRegion m_edges;
+  EdgeTransferIdsInRegion m_edgesTransfers;
+  IdsInRegion m_transfers;
+  IdsInRegion m_gates;
+};
+
 // Class for merging scattered GTFS feeds into one World feed with static ids.
+// The usage scenario consists of steps:
+// 1) Initialize |WorldFeed| instance with |IdGenerator| for correct id assignment to GTFS entities,
+// |ColorPicker| for choosing route colors from our palette, |CountriesFilesAffiliation| for
+// splitting result feed into regions.
+// 2) Call SetFeed(...) method to convert GTFS entities into objects convenient for dumping to json.
+// 3) Call Save(...) to save result data as a set of json files in the specified directory.
 class WorldFeed
 {
 public:
-  WorldFeed(IdGenerator & generator, ColorPicker & colorPicker);
+  WorldFeed(IdGenerator & generator, ColorPicker & colorPicker,
+            feature::CountriesFilesAffiliation & mwmMatcher);
   // Transforms GTFS feed into the global feed.
   bool SetFeed(gtfs::Feed && feed);
 
@@ -286,10 +328,12 @@ public:
 private:
   friend class WorldFeedIntegrationTests;
 
+  void SaveRegions(std::string const & worldFeedDir, std::string const & region, bool overwrite);
+
   bool SetFeedLanguage();
   // Fills networks from GTFS agencies data.
   bool FillNetworks();
-  // Fills routes from GTFS foutes data.
+  // Fills routes from GTFS routes data.
   bool FillRoutes();
   // Fills lines and corresponding shapes from GTFS trips and shapes.
   bool FillLinesAndShapes();
@@ -334,10 +378,31 @@ private:
 
   LineIntervals GetFrequencies(std::unordered_map<std::string, LineIntervals> & cache,
                                std::string const & tripId);
+
+  // Splits data into regions.
+  void SplitFeedIntoRegions();
+  // Splits |m_stops|, |m_edges| and |m_edgesTransfer| into regions. The following stops are
+  // added to corresponding regions: stops inside borders; stops which are connected with an edge
+  // from |m_edges| or |m_edgesTransfer| with stops inside borders. Edge from |m_edges| or
+  // |m_edgesTransfer| is added to the region if one of its stop ids lies inside mwm.
+  void SplitStopsBasedData();
+  // Splits |m_lines|, |m_shapes|, |m_routes| and |m_networks| into regions. If one of the line
+  // stops (|m_stopIds|) lies inside region, then this line is added to this region. But only stops
+  // whose stop ids are contained in this region will be attached to the line in this region. Shape,
+  // route or network is added to the region if it is linked to the line in this region.
+  void SplitLinesBasedData();
+  // Splits |m_transfers| and |m_gates| into regions. Transfer is added to the region if there is
+  // stop in |m_stopsIds| which is inside this region. Gate is added to the region if there is stop
+  // in |m_weights| which is inside the region.
+  void SplitSupplementalData();
+  // Extend existing ids containers by appending to them |fromId| and |toId|. If one of the ids is
+  // present in region, then the other is also added.
+  std::pair<Regions, Regions> ExtendRegionsByPair(TransitId fromId, TransitId toId);
+
   // Current GTFS feed which is being merged to the global feed.
   gtfs::Feed m_feed;
 
-  // Entities for json'izing and feeding to the generator_tool.
+  // Entities for json'izing and feeding to the generator_tool (Not split by regions).
   Networks m_networks;
   Routes m_routes;
   Lines m_lines;
@@ -348,10 +413,15 @@ private:
   Transfers m_transfers;
   Gates m_gates;
 
+  // Ids of entities for json'izing, split by regions.
+  TransitByRegion m_splitting;
+
   // Generator of ids, globally unique and constant between re-runs.
   IdGenerator & m_idGenerator;
   // Color name picker of the nearest color for route RBG from our constant list of transfer colors.
   ColorPicker & m_colorPicker;
+  // Mwm matcher for m2:Points representing stops and other entities.
+  feature::CountriesFilesAffiliation & m_affiliation;
 
   // GTFS id -> entity hash mapping. Maps GTFS id string (unique only for current feed) to the
   // globally unique hash.
diff --git a/transit/world_feed/world_feed_integration_tests/CMakeLists.txt b/transit/world_feed/world_feed_integration_tests/CMakeLists.txt
index d1590bd051..83562fdfb5 100644
--- a/transit/world_feed/world_feed_integration_tests/CMakeLists.txt
+++ b/transit/world_feed/world_feed_integration_tests/CMakeLists.txt
@@ -10,4 +10,5 @@ omim_add_test(${PROJECT_NAME} ${SRC})
 omim_link_libraries(
   ${PROJECT_NAME}
   world_feed
+  generator
 )
diff --git a/transit/world_feed/world_feed_integration_tests/world_feed_integration_tests.cpp b/transit/world_feed/world_feed_integration_tests/world_feed_integration_tests.cpp
index e3f8318d5e..36ace0f263 100644
--- a/transit/world_feed/world_feed_integration_tests/world_feed_integration_tests.cpp
+++ b/transit/world_feed/world_feed_integration_tests/world_feed_integration_tests.cpp
@@ -1,5 +1,7 @@
 #include "testing/testing.hpp"
 
+#include "generator/affiliation.hpp"
+
 #include "transit/world_feed/world_feed.hpp"
 
 #include "platform/platform.hpp"
@@ -26,7 +28,9 @@ namespace transit
 class WorldFeedIntegrationTests
 {
 public:
-  WorldFeedIntegrationTests() : m_globalFeed(m_generator, m_colorPicker)
+  WorldFeedIntegrationTests()
+    : m_mwmMatcher(GetTestingOptions().m_resourcePath, false /* haveBordersForWholeWorld */)
+    , m_globalFeed(m_generator, m_colorPicker, m_mwmMatcher)
   {
     auto const & options = GetTestingOptions();
 
@@ -91,6 +95,7 @@ private:
   std::string m_testPath;
   IdGenerator m_generator;
   transit::ColorPicker m_colorPicker;
+  feature::CountriesFilesAffiliation m_mwmMatcher;
   WorldFeed m_globalFeed;
 };