diff --git a/routing/cross_mwm_graph.hpp b/routing/cross_mwm_graph.hpp
index 065740499f..16559c332a 100644
--- a/routing/cross_mwm_graph.hpp
+++ b/routing/cross_mwm_graph.hpp
@@ -16,6 +16,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace routing
@@ -89,6 +90,15 @@ public:
 
   void Clear();
 
+  template <typename Fn>
+  void ForEachTransition(NumMwmId numMwmId, bool isEnter, Fn && fn)
+  {
+    if (CrossMwmSectionExists(numMwmId))
+      m_crossMwmIndexGraph.ForEachTransition(numMwmId, isEnter, std::forward<Fn>(fn));
+    else
+      m_crossMwmOsrmGraph.ForEachTransition(numMwmId, isEnter, std::forward<Fn>(fn));
+  }
+
 private:
   struct ClosestSegment
   {
@@ -126,7 +136,7 @@ private:
   /// added to |twins| anyway. If there's no such segment in mwm it tries find the closet one and adds it
   /// to |minDistSegs|.
   void FindBestTwins(NumMwmId sMwmId, bool isOutgoing, FeatureType const & ft, m2::PointD const & point,
-                     map<NumMwmId, ClosestSegment> & minDistSegs, vector<Segment> & twins);
+                     std::map<NumMwmId, ClosestSegment> & minDistSegs, std::vector<Segment> & twins);
 
   /// \brief Fills |neighbors| with number mwm id of all loaded neighbors of |numMwmId| and
   /// sets |allNeighborsHaveCrossMwmSection| to true if all loaded neighbors have cross mwm section
diff --git a/routing/cross_mwm_index_graph.hpp b/routing/cross_mwm_index_graph.hpp
index 51e2c7aa89..e81ad46466 100644
--- a/routing/cross_mwm_index_graph.hpp
+++ b/routing/cross_mwm_index_graph.hpp
@@ -43,6 +43,23 @@ public:
   bool InCache(NumMwmId numMwmId) const { return m_connectors.count(numMwmId) != 0; }
   CrossMwmConnector const & GetCrossMwmConnectorWithTransitions(NumMwmId numMwmId);
 
+  template <typename Fn>
+  void ForEachTransition(NumMwmId numMwmId, bool isEnter, Fn && fn)
+  {
+    if (isEnter)
+    {
+      std::vector<Segment> const & enters = GetCrossMwmConnectorWithTransitions(numMwmId).GetEnters();
+      for (Segment const & enter : enters)
+        fn(enter);
+    }
+    else
+    {
+      std::vector<Segment> const & exits = GetCrossMwmConnectorWithTransitions(numMwmId).GetExits();
+      for (Segment const & exit : exits)
+        fn(exit);
+    }
+  }
+
 private:
   CrossMwmConnector const & GetCrossMwmConnectorWithWeights(NumMwmId numMwmId);
 
diff --git a/routing/cross_mwm_osrm_graph.hpp b/routing/cross_mwm_osrm_graph.hpp
index f446eb77ab..444681147c 100644
--- a/routing/cross_mwm_osrm_graph.hpp
+++ b/routing/cross_mwm_osrm_graph.hpp
@@ -31,6 +31,21 @@ public:
   void Clear();
   TransitionPoints GetTransitionPoints(Segment const & s, bool isOutgoing);
 
+  template <typename Fn>
+  void ForEachTransition(NumMwmId numMwmId, bool isEnter, Fn && fn)
+  {
+    if (isEnter)
+    {
+      for (auto const & kv : GetSegmentMaps(numMwmId).m_ingoing)
+        fn(kv.first);
+    }
+    else
+    {
+      for (auto const & kv : GetSegmentMaps(numMwmId).m_outgoing)
+        fn(kv.first);
+    }
+  }
+
 private:
   struct TransitionSegments
   {
diff --git a/routing/edge_estimator.cpp b/routing/edge_estimator.cpp
index 15efa0ad50..45a629d336 100644
--- a/routing/edge_estimator.cpp
+++ b/routing/edge_estimator.cpp
@@ -46,6 +46,7 @@ public:
   // EdgeEstimator overrides:
   double CalcSegmentWeight(Segment const & segment, RoadGeometry const & road) const override;
   double CalcHeuristic(m2::PointD const & from, m2::PointD const & to) const override;
+  double CalcLeapEdgeTime(m2::PointD const & from, m2::PointD const & to) const override;
   double GetUTurnPenalty() const override;
   bool LeapIsAllowed(NumMwmId mwmId) const override;
 
@@ -100,6 +101,14 @@ double CarEdgeEstimator::CalcHeuristic(m2::PointD const & from, m2::PointD const
   return TimeBetweenSec(from, to, m_maxSpeedMPS);
 }
 
+double CarEdgeEstimator::CalcLeapEdgeTime(m2::PointD const & from, m2::PointD const & to) const
+{
+  // Let us assume for the time being that
+  // leap edges will be added with a half of max speed.
+  // @TODO(bykoianko) It's necessary to gather statistics to calculate better factor(s) instead of one below.
+  return TimeBetweenSec(from, to, m_maxSpeedMPS / 2.0);
+}
+
 double CarEdgeEstimator::GetUTurnPenalty() const
 {
   // Adds 2 minutes penalty for U-turn. The value is quite arbitrary
diff --git a/routing/edge_estimator.hpp b/routing/edge_estimator.hpp
index b9c954180f..a13fd0490e 100644
--- a/routing/edge_estimator.hpp
+++ b/routing/edge_estimator.hpp
@@ -24,6 +24,10 @@ public:
 
   virtual double CalcSegmentWeight(Segment const & segment, RoadGeometry const & road) const = 0;
   virtual double CalcHeuristic(m2::PointD const & from, m2::PointD const & to) const = 0;
+  // Returns time in seconds is taken for going from point |from| to point |to| along a leap (fake) edge |from|-|to|.
+  // Note 1. The result of the method should be used if it's necessary to add a leap (fake) edge (|form|, |to|) in road graph.
+  // Note 2. The result of the method should be less or equal to CalcHeuristic(|form|, |to|).
+  virtual double CalcLeapEdgeTime(m2::PointD const & from, m2::PointD const & to) const = 0;
   virtual double GetUTurnPenalty() const = 0;
   // The leap is the shortcut edge from mwm border enter to exit.
   // Router can't use leaps on some mwms: e.g. mwm with loaded traffic data.
diff --git a/routing/index_graph_starter.cpp b/routing/index_graph_starter.cpp
index 064d96bb5b..b4f4d1c991 100644
--- a/routing/index_graph_starter.cpp
+++ b/routing/index_graph_starter.cpp
@@ -54,13 +54,13 @@ void IndexGraphStarter::GetEdgesList(Segment const & segment, bool isOutgoing,
 
   if (segment == kStartFakeSegment)
   {
-    GetFakeToNormalEdges(m_start, edges);
+    GetFakeToNormalEdges(m_start, isOutgoing, edges);
     return;
   }
 
   if (segment == kFinishFakeSegment)
   {
-    GetFakeToNormalEdges(m_finish, edges);
+    GetFakeToNormalEdges(m_finish, isOutgoing, edges);
     return;
   }
 
@@ -70,8 +70,15 @@ void IndexGraphStarter::GetEdgesList(Segment const & segment, bool isOutgoing,
 }
 
 void IndexGraphStarter::GetFakeToNormalEdges(FakeVertex const & fakeVertex,
+                                             bool isOutgoing,
                                              vector<SegmentEdge> & edges)
 {
+  if (m_graph.GetMode() == WorldGraph::Mode::LeapsOnly)
+  {
+    ConnectLeapToTransitions(fakeVertex, isOutgoing, edges);
+    return;
+  }
+
   GetFakeToNormalEdge(fakeVertex, true /* forward */, edges);
 
   if (!m_graph.GetRoadGeometry(fakeVertex.GetMwmId(), fakeVertex.GetFeatureId()).IsOneWay())
@@ -84,7 +91,7 @@ void IndexGraphStarter::GetFakeToNormalEdge(FakeVertex const & fakeVertex, bool
   Segment const segment(fakeVertex.GetMwmId(), fakeVertex.GetFeatureId(),
                         fakeVertex.GetSegmentIdx(), forward);
   m2::PointD const & pointTo = GetPoint(segment, true /* front */);
-  double const weight = m_graph.GetEstimator().CalcHeuristic(fakeVertex.GetPoint(), pointTo);
+  double const weight = m_graph.GetEstimator().CalcLeapEdgeTime(fakeVertex.GetPoint(), pointTo);
   edges.emplace_back(segment, weight);
 }
 
@@ -92,11 +99,46 @@ void IndexGraphStarter::GetNormalToFakeEdge(Segment const & segment, FakeVertex
                                             Segment const & fakeSegment, bool isOutgoing,
                                             vector<SegmentEdge> & edges)
 {
+  m2::PointD const & pointFrom = GetPoint(segment, isOutgoing);
+  if (segment.GetMwmId() == fakeVertex.GetMwmId() && m_graph.GetMode() == WorldGraph::Mode::LeapsOnly)
+  {
+    // It's assumed here that GetEstimator().CalcLeapEdgeTime(p1, p2) == GetEstimator().CalcLeapEdgeTime(p2, p1).
+    if (m_graph.IsTransition(segment, isOutgoing))
+      edges.emplace_back(fakeSegment, m_graph.GetEstimator().CalcLeapEdgeTime(pointFrom, fakeVertex.GetPoint()));
+    return;
+  }
+
   if (!fakeVertex.Fits(segment))
     return;
 
-  m2::PointD const & pointFrom = GetPoint(segment, isOutgoing);
-  double const weight = m_graph.GetEstimator().CalcHeuristic(pointFrom, fakeVertex.GetPoint());
-  edges.emplace_back(fakeSegment, weight);
+  edges.emplace_back(fakeSegment, m_graph.GetEstimator().CalcLeapEdgeTime(pointFrom, fakeVertex.GetPoint()));
+}
+
+void IndexGraphStarter::ConnectLeapToTransitions(FakeVertex const & fakeVertex, bool isOutgoing,
+                                                 vector<SegmentEdge> & edges)
+{
+  edges.clear();
+  m2::PointD const & segmentPoint = fakeVertex.GetPoint();
+
+  // Note. If |isOutgoing| == true it's necessary to add edges which connect the start with all
+  // exits of its mwm.
+  // So |isEnter| below should be set to false. If |isOutgoing| == false all enters of the
+  // finish mwm should be connected with the finish point. So |isEnter| below should be set to true.
+  m_graph.ForEachTransition(
+      fakeVertex.GetMwmId(), !isOutgoing /* isEnter */, [&](Segment const & transition) {
+        // It's assumed here that GetEstimator().CalcLeapEdgeTime(p1, p2) ==
+        // GetEstimator().CalcLeapEdgeTime(p2, p1).
+        edges.emplace_back(transition, m_graph.GetEstimator().CalcLeapEdgeTime(
+          segmentPoint, GetPoint(transition, isOutgoing)));
+      });
+}
+
+Segment const & IndexGraphStarter::ConvertSegment(Segment const & segment)
+{
+  if (segment == kStartFakeSegment)
+    return m_start.GetSegment();
+  if (segment == kFinishFakeSegment)
+    return m_finish.GetSegment();
+  return segment;
 }
 }  // namespace routing
diff --git a/routing/index_graph_starter.hpp b/routing/index_graph_starter.hpp
index 54787c512c..2b76c1c906 100644
--- a/routing/index_graph_starter.hpp
+++ b/routing/index_graph_starter.hpp
@@ -24,33 +24,28 @@ public:
   {
   public:
     FakeVertex(NumMwmId mwmId, uint32_t featureId, uint32_t segmentIdx, m2::PointD const & point)
-      : m_featureId(featureId), m_segmentIdx(segmentIdx), m_mwmId(mwmId), m_point(point)
+      : m_segment(mwmId, featureId, segmentIdx, true /* forward */), m_point(point)
     {
     }
 
     FakeVertex(Segment const & segment, m2::PointD const & point)
-      : m_featureId(segment.GetFeatureId())
-      , m_segmentIdx(segment.GetSegmentIdx())
-      , m_mwmId(segment.GetMwmId())
-      , m_point(point)
+      : m_segment(segment), m_point(point)
     {
     }
 
-    NumMwmId GetMwmId() const { return m_mwmId; }
-    uint32_t GetFeatureId() const { return m_featureId; }
-    uint32_t GetSegmentIdx() const { return m_segmentIdx; }
+    NumMwmId GetMwmId() const { return m_segment.GetMwmId(); }
+    uint32_t GetFeatureId() const { return m_segment.GetFeatureId(); }
+    uint32_t GetSegmentIdx() const { return m_segment.GetSegmentIdx(); }
+    Segment const & GetSegment() const { return m_segment; }
     m2::PointD const & GetPoint() const { return m_point; }
-
     bool Fits(Segment const & segment) const
     {
-      return segment.GetFeatureId() == m_featureId && segment.GetSegmentIdx() == m_segmentIdx &&
-             segment.GetMwmId() == m_mwmId;
+      return segment.GetMwmId() == GetMwmId() && segment.GetFeatureId() == GetFeatureId() &&
+             segment.GetSegmentIdx() == GetSegmentIdx();
     }
 
   private:
-    uint32_t const m_featureId;
-    uint32_t const m_segmentIdx;
-    NumMwmId const m_mwmId;
+    Segment m_segment;
     m2::PointD const m_point;
   };
 
@@ -99,6 +94,8 @@ public:
     return segment.GetFeatureId() == kFakeFeatureId;
   }
 
+  Segment const & ConvertSegment(Segment const & segment);
+
 private:
   static uint32_t constexpr kFakeFeatureId = numeric_limits<uint32_t>::max();
   static uint32_t constexpr kFakeSegmentIdx = numeric_limits<uint32_t>::max();
@@ -107,12 +104,19 @@ private:
   static Segment constexpr kFinishFakeSegment =
       Segment(kFakeNumMwmId, kFakeFeatureId, kFakeSegmentIdx, true);
 
-  void GetFakeToNormalEdges(FakeVertex const & fakeVertex, vector<SegmentEdge> & edges);
+  void GetFakeToNormalEdges(FakeVertex const & fakeVertex, bool isOutgoing,
+                            vector<SegmentEdge> & edges);
   void GetFakeToNormalEdge(FakeVertex const & fakeVertex, bool forward,
                            vector<SegmentEdge> & edges);
   void GetNormalToFakeEdge(Segment const & segment, FakeVertex const & fakeVertex,
                            Segment const & fakeSegment, bool isOutgoing,
                            vector<SegmentEdge> & edges);
+  /// \brief If |toExits| == true fills |edges| with SegmentEdge(s) which connects
+  /// |segment| with all exits of mwm.
+  /// \brief If |toExits| == false fills |edges| with SegmentEdge(s) which connects
+  /// all enters to mwm with |segment|.
+  void ConnectLeapToTransitions(FakeVertex const & fakeVertex, bool isOutgoing,
+                                vector<SegmentEdge> & edges);
 
   WorldGraph & m_graph;
   FakeVertex const m_start;
diff --git a/routing/index_router.cpp b/routing/index_router.cpp
index a9ef90a35f..616276a83b 100644
--- a/routing/index_router.cpp
+++ b/routing/index_router.cpp
@@ -138,7 +138,13 @@ IRouter::ResultCode IndexRouter::DoCalculateRoute(string const & startCountry,
                                  m_index, m_indexManager),
       IndexGraphLoader::Create(m_numMwmIds, m_vehicleModelFactory, m_estimator, m_index),
       m_estimator);
-  graph.SetMode(forSingleMwm ? WorldGraph::Mode::SingleMwm : WorldGraph::Mode::WorldWithLeaps);
+
+  auto const getRoutingMode = [&](){
+    return AreMwmsNear(start.GetMwmId(), finish.GetMwmId()) ? WorldGraph::Mode::LeapsIfPossible
+                                                            : WorldGraph::Mode::LeapsOnly;
+  };
+  graph.SetMode(forSingleMwm ? WorldGraph::Mode::SingleMwm : getRoutingMode());
+  LOG(LINFO, ("Routing in mode:", graph.GetMode()));
 
   IndexGraphStarter starter(start, finish, graph);
 
@@ -230,27 +236,30 @@ IRouter::ResultCode IndexRouter::ProcessLeaps(vector<Segment> const & input,
   output.reserve(input.size());
 
   WorldGraph & worldGraph = starter.GetGraph();
+  WorldGraph::Mode const worldRouteMode = worldGraph.GetMode();
   worldGraph.SetMode(WorldGraph::Mode::SingleMwm);
 
   for (size_t i = 0; i < input.size(); ++i)
   {
     Segment const & current = input[i];
-    if (!starter.IsLeap(current.GetMwmId()))
+    if (worldRouteMode == WorldGraph::Mode::LeapsIfPossible && !starter.IsLeap(current.GetMwmId()))
     {
       output.push_back(current);
       continue;
     }
 
+    Segment const & convertedCurrent = starter.ConvertSegment(input[i]);
     ++i;
     CHECK_LESS(i, input.size(), ());
-    Segment const & next = input[i];
-
+    Segment const & convertedNext = starter.ConvertSegment(input[i]);
     CHECK_EQUAL(
-        current.GetMwmId(), next.GetMwmId(),
+        convertedCurrent.GetMwmId(), convertedNext.GetMwmId(),
         ("Different mwm ids for leap enter and exit, i:", i, "size of input:", input.size()));
 
-    IndexGraphStarter::FakeVertex const start(current, starter.GetPoint(current, true /* front */));
-    IndexGraphStarter::FakeVertex const finish(next, starter.GetPoint(next, true /* front */));
+    IndexGraphStarter::FakeVertex const start(convertedCurrent,
+                                              starter.GetPoint(convertedCurrent, true /* front */));
+    IndexGraphStarter::FakeVertex const finish(convertedNext,
+                                               starter.GetPoint(convertedNext, true /* front */));
     IndexGraphStarter leapStarter(start, finish, starter.GetGraph());
 
     // Clear previous loaded graphs.
@@ -293,7 +302,7 @@ bool IndexRouter::RedressRoute(vector<Segment> const & segments, RouterDelegate
 
   IndexRoadGraph roadGraph(m_numMwmIds, starter, segments, junctions, m_index);
   if (!forSingleMwm)
-    starter.GetGraph().SetMode(WorldGraph::Mode::WorldWithoutLeaps);
+    starter.GetGraph().SetMode(WorldGraph::Mode::NoLeaps);
 
   CHECK(m_directionsEngine, ());
   ReconstructRoute(*m_directionsEngine, roadGraph, m_trafficStash, delegate, junctions, route);
@@ -319,6 +328,17 @@ bool IndexRouter::RedressRoute(vector<Segment> const & segments, RouterDelegate
   return true;
 }
 
+bool IndexRouter::AreMwmsNear(NumMwmId startId, NumMwmId finishId) const
+{
+  m2::RectD const startMwmRect = m_countryRectFn(m_numMwmIds->GetFile(startId).GetName());
+  bool areMwmsNear = false;
+  m_numMwmTree->ForEachInRect(startMwmRect, [&](NumMwmId id) {
+    if (id == finishId)
+      areMwmsNear = true;
+  });
+  return areMwmsNear;
+}
+
 // static
 unique_ptr<IndexRouter> IndexRouter::CreateCarRouter(TCountryFileFn const & countryFileFn,
                                                      CourntryRectFn const & coutryRectFn,
diff --git a/routing/index_router.hpp b/routing/index_router.hpp
index 4aee8ace8d..5bc3049939 100644
--- a/routing/index_router.hpp
+++ b/routing/index_router.hpp
@@ -77,6 +77,8 @@ private:
   bool RedressRoute(vector<Segment> const & segments, RouterDelegate const & delegate,
                     bool forSingleMwm, IndexGraphStarter & starter, Route & route) const;
 
+  bool AreMwmsNear(NumMwmId startId, NumMwmId finishId) const;
+
   string const m_name;
   Index & m_index;
   TCountryFileFn const m_countryFileFn;
diff --git a/routing/routing_tests/index_graph_tools.cpp b/routing/routing_tests/index_graph_tools.cpp
index c2c8fd4565..8d765035d2 100644
--- a/routing/routing_tests/index_graph_tools.cpp
+++ b/routing/routing_tests/index_graph_tools.cpp
@@ -68,6 +68,12 @@ double WeightedEdgeEstimator::CalcHeuristic(m2::PointD const & /* from */,
   return 0.0;
 }
 
+double WeightedEdgeEstimator::CalcLeapEdgeTime(m2::PointD const & /* from */,
+                                               m2::PointD const & /* to */) const
+{
+  return 0.0;
+}
+
 double WeightedEdgeEstimator::GetUTurnPenalty() const { return 0.0; }
 
 bool WeightedEdgeEstimator::LeapIsAllowed(NumMwmId /* mwmId */) const { return false; }
diff --git a/routing/routing_tests/index_graph_tools.hpp b/routing/routing_tests/index_graph_tools.hpp
index f904672ecc..fbb5a6d772 100644
--- a/routing/routing_tests/index_graph_tools.hpp
+++ b/routing/routing_tests/index_graph_tools.hpp
@@ -101,6 +101,7 @@ public:
   // EdgeEstimator overrides:
   double CalcSegmentWeight(Segment const & segment, RoadGeometry const & /* road */) const override;
   double CalcHeuristic(m2::PointD const & /* from */, m2::PointD const & /* to */) const override;
+  double CalcLeapEdgeTime(m2::PointD const & /* from */, m2::PointD const & /* to */) const override;
   double GetUTurnPenalty() const override;
   bool LeapIsAllowed(NumMwmId /* mwmId */) const override;
 
diff --git a/routing/world_graph.cpp b/routing/world_graph.cpp
index 1f7e4c1249..814fbf5e7e 100644
--- a/routing/world_graph.cpp
+++ b/routing/world_graph.cpp
@@ -12,10 +12,9 @@ WorldGraph::WorldGraph(unique_ptr<CrossMwmGraph> crossMwmGraph, unique_ptr<Index
   CHECK(m_estimator, ());
 }
 
-void WorldGraph::GetEdgeList(Segment const & segment, bool isOutgoing, bool isLeap,
-                             vector<SegmentEdge> & edges)
+void WorldGraph::GetEdgeList(Segment const & segment, bool isOutgoing, bool isLeap, std::vector<SegmentEdge> & edges)
 {
-  if (isLeap && m_mode == Mode::WorldWithLeaps)
+  if (m_mode != Mode::NoLeaps && (isLeap || m_mode == Mode::LeapsOnly))
   {
     CHECK(m_crossMwmGraph, ());
     if (m_crossMwmGraph->IsTransition(segment, isOutgoing))
@@ -59,4 +58,16 @@ void WorldGraph::GetTwins(Segment const & segment, bool isOutgoing, vector<Segme
     edges.emplace_back(twin, weight);
   }
 }
+
+string DebugPrint(WorldGraph::Mode mode)
+{
+  switch (mode)
+  {
+    case WorldGraph::Mode::SingleMwm: return "SingleMwm";
+    case WorldGraph::Mode::LeapsOnly: return "LeapsOnly";
+    case WorldGraph::Mode::LeapsIfPossible: return "LeapsIfPossible";
+    case WorldGraph::Mode::NoLeaps: return "NoLeaps";
+  }
+  return "Unknown mode";
+}
 }  // namespace routing
diff --git a/routing/world_graph.hpp b/routing/world_graph.hpp
index be568b12de..47407331ea 100644
--- a/routing/world_graph.hpp
+++ b/routing/world_graph.hpp
@@ -9,6 +9,7 @@
 
 #include <memory>
 #include <unordered_map>
+#include <utility>
 #include <vector>
 
 namespace routing
@@ -19,15 +20,15 @@ public:
   enum class Mode
   {
     SingleMwm,
-    WorldWithLeaps,
-    WorldWithoutLeaps,
+    LeapsOnly,
+    LeapsIfPossible,
+    NoLeaps,
   };
 
   WorldGraph(std::unique_ptr<CrossMwmGraph> crossMwmGraph, std::unique_ptr<IndexGraphLoader> loader,
              std::shared_ptr<EdgeEstimator> estimator);
 
-  void GetEdgeList(Segment const & segment, bool isOutgoing, bool isLeap,
-                   std::vector<SegmentEdge> & edges);
+  void GetEdgeList(Segment const & segment, bool isOutgoing, bool isLeap, std::vector<SegmentEdge> & edges);
 
   IndexGraph & GetIndexGraph(NumMwmId numMwmId) { return m_loader->GetIndexGraph(numMwmId); }
   EdgeEstimator const & GetEstimator() const { return *m_estimator; }
@@ -38,6 +39,15 @@ public:
   // Clear memory used by loaded index graphs.
   void ClearIndexGraphs() { m_loader->Clear(); }
   void SetMode(Mode mode) { m_mode = mode; }
+  Mode GetMode() const { return m_mode; }
+
+  template <typename Fn>
+  void ForEachTransition(NumMwmId numMwmId, bool isEnter, Fn && fn)
+  {
+    m_crossMwmGraph->ForEachTransition(numMwmId, isEnter, std::forward<Fn>(fn));
+  }
+
+  bool IsTransition(Segment const & s, bool isOutgoing) { return m_crossMwmGraph->IsTransition(s, isOutgoing);}
 
 private:  
   void GetTwins(Segment const & s, bool isOutgoing, std::vector<SegmentEdge> & edges);
@@ -48,4 +58,6 @@ private:
   std::vector<Segment> m_twins;
   Mode m_mode = Mode::SingleMwm;
 };
+
+std::string DebugPrint(WorldGraph::Mode mode);
 }  // namespace routing