diff --git a/map/framework.cpp b/map/framework.cpp
index 61b53ffb93..16674fcbce 100644
--- a/map/framework.cpp
+++ b/map/framework.cpp
@@ -1196,6 +1196,12 @@ void Framework::PrepareSearch(bool hasPt, double lat, double lon)
 
 bool Framework::Search(search::SearchParams const & params)
 {
+  if (params.m_query == "?ariadna")
+  {
+    LOG(LINFO, ("Enable mwm cross mode"));
+    m_routingSession.ActivateAdditionalFeatures();
+    return false;
+  }
 #ifdef FIXED_LOCATION
   search::SearchParams rParams(params);
   if (params.IsValidPosition())
diff --git a/map/routing_session.hpp b/map/routing_session.hpp
index fa6148e453..a0cd38566c 100644
--- a/map/routing_session.hpp
+++ b/map/routing_session.hpp
@@ -63,6 +63,8 @@ public:
   void DeleteIndexFile(string const & fileName);
   void MatchLocationToRoute(location::GpsInfo & location, location::RouteMatchingInfo & routeMatchingInfo) const;
 
+  void ActivateAdditionalFeatures() {m_router->ActivateAdditionalFeatures();}
+
 private:
   struct DoReadyCallback
   {
diff --git a/routing/cross_routing_context.hpp b/routing/cross_routing_context.hpp
index 5f0ee28c4a..a09b5c0690 100644
--- a/routing/cross_routing_context.hpp
+++ b/routing/cross_routing_context.hpp
@@ -9,33 +9,34 @@
 
 namespace routing
 {
+using WritedEdgeWeight = uint32_t;
 
 class CrossRoutingContext
 {
-  std::vector<size_t> m_ingoingNodes;
-  std::vector<std::pair<size_t,size_t> > m_outgoingNodes;
-  std::vector<int> m_adjacencyMatrix;
+  std::vector<uint32_t> m_ingoingNodes;
+  std::vector<std::pair<uint32_t,uint32_t> > m_outgoingNodes;
+  std::vector<WritedEdgeWeight> m_adjacencyMatrix;
   std::vector<string> m_neighborMwmList;
 
 public:
 
   const string & getOutgoingMwmName(size_t mwmIndex) const
   {
-    CHECK(mwmIndex<m_neighborMwmList.size(), (mwmIndex,m_neighborMwmList.size()));
+    ASSERT(mwmIndex < m_neighborMwmList.size(), ("Routing context out of size mwm name index:", mwmIndex, m_neighborMwmList.size()));
     return m_neighborMwmList[mwmIndex];
   }
 
-  std::pair<std::vector<size_t>::const_iterator, std::vector<size_t>::const_iterator> GetIngoingIterators() const
+  std::pair<std::vector<uint32_t>::const_iterator, std::vector<uint32_t>::const_iterator> GetIngoingIterators() const
   {
     return make_pair(m_ingoingNodes.cbegin(), m_ingoingNodes.cend());
   }
 
-  std::pair<std::vector<std::pair<size_t,size_t>>::const_iterator, std::vector<std::pair<size_t,size_t>>::const_iterator> GetOutgoingIterators() const
+  std::pair<std::vector<std::pair<uint32_t,uint32_t>>::const_iterator, std::vector<std::pair<uint32_t,uint32_t>>::const_iterator> GetOutgoingIterators() const
   {
     return make_pair(m_outgoingNodes.cbegin(), m_outgoingNodes.cend());
   }
 
-  int getAdjacencyCost(std::vector<size_t>::const_iterator ingoing_iter, std::vector<std::pair<size_t,size_t>>::const_iterator outgoin_iter) const
+  WritedEdgeWeight getAdjacencyCost(std::vector<uint32_t>::const_iterator ingoing_iter, std::vector<std::pair<uint32_t,uint32_t>>::const_iterator outgoin_iter) const
   {
     size_t ingoing_index = std::distance(m_ingoingNodes.cbegin(), ingoing_iter);
     size_t outgoing_index = std::distance(m_outgoingNodes.cbegin(), outgoin_iter);
@@ -46,33 +47,35 @@ public:
 
   void Load(Reader const & r)
   {
+    //Already loaded check
     if (m_adjacencyMatrix.size())
-      return; //Already loaded
-    size_t size, pos=0;
-    r.Read(pos, &size, sizeof(size_t));
-    pos += sizeof(size_t);
+      return;
+
+    uint32_t size, pos = 0;
+    r.Read(pos, &size, sizeof(uint32_t));
+    pos += sizeof(uint32_t);
     m_ingoingNodes.resize(size);
-    r.Read(pos, &m_ingoingNodes[0], sizeof(size_t)*size);
-    pos += sizeof(size_t)*size;
+    r.Read(pos, &m_ingoingNodes[0], sizeof(uint32_t)*size);
+    pos += sizeof(uint32_t) * size;
 
-    r.Read(pos, &size, sizeof(size_t));
-    pos += sizeof(size_t);
+    r.Read(pos, &size, sizeof(uint32_t));
+    pos += sizeof(uint32_t);
     m_outgoingNodes.resize(size);
-    r.Read(pos, &(m_outgoingNodes[0]), sizeof(std::pair<size_t,size_t>) * size);
-    pos += sizeof(std::pair<size_t,size_t>) * size;
+    r.Read(pos, &(m_outgoingNodes[0]), sizeof(std::pair<uint32_t,uint32_t>) * size);
+    pos += sizeof(std::pair<uint32_t,uint32_t>) * size;
 
-    m_adjacencyMatrix.resize(m_ingoingNodes.size()*m_outgoingNodes.size());
-    r.Read(pos, &m_adjacencyMatrix[0], sizeof(int)*m_adjacencyMatrix.size());
-    pos += sizeof(int)*m_adjacencyMatrix.size();
+    m_adjacencyMatrix.resize(m_ingoingNodes.size() * m_outgoingNodes.size());
+    r.Read(pos, &m_adjacencyMatrix[0], sizeof(WritedEdgeWeight) * m_adjacencyMatrix.size());
+    pos += sizeof(WritedEdgeWeight) * m_adjacencyMatrix.size();
 
-    size_t strsize;
-    r.Read(pos, &strsize, sizeof(size_t));
-    pos += sizeof(size_t);
-    for (int i = 0; i < strsize; ++i)
+    uint32_t strsize;
+    r.Read(pos, &strsize, sizeof(uint32_t));
+    pos += sizeof(uint32_t);
+    for (uint32_t i = 0; i < strsize; ++i)
     {
       char * tmpString;
-      r.Read(pos, &size, sizeof(size_t));
-      pos += sizeof(size_t);
+      r.Read(pos, &size, sizeof(uint32_t));
+      pos += sizeof(uint32_t);
       tmpString = new char[size];
       r.Read(pos, tmpString, size);
       m_neighborMwmList.push_back(string(tmpString, size));
@@ -85,23 +88,23 @@ public:
   void Save(Writer & w)
   {
     sort(m_ingoingNodes.begin(), m_ingoingNodes.end());
-    size_t size = m_ingoingNodes.size();
-    w.Write(&size, sizeof(size_t));
-    w.Write(&(m_ingoingNodes[0]), sizeof(size_t) * size);
+    uint32_t size = m_ingoingNodes.size();
+    w.Write(&size, sizeof(uint32_t));
+    w.Write(&(m_ingoingNodes[0]), sizeof(uint32_t) * size);
 
     size = m_outgoingNodes.size();
-    w.Write(&size, sizeof(size_t));
-    w.Write(&(m_outgoingNodes[0]), sizeof(std::pair<size_t,size_t>) * size);
+    w.Write(&size, sizeof(uint32_t));
+    w.Write(&(m_outgoingNodes[0]), sizeof(std::pair<uint32_t,uint32_t>) * size);
 
     CHECK(m_adjacencyMatrix.size() == m_outgoingNodes.size()*m_ingoingNodes.size(), ());
-    w.Write(&(m_adjacencyMatrix[0]), sizeof(int) * m_adjacencyMatrix.size());
+    w.Write(&(m_adjacencyMatrix[0]), sizeof(WritedEdgeWeight) * m_adjacencyMatrix.size());
 
     size = m_neighborMwmList.size();
-    w.Write(&size, sizeof(size_t));
+    w.Write(&size, sizeof(uint32_t));
     for (string & neighbor: m_neighborMwmList)
     {
       size = neighbor.size();
-      w.Write(&size, sizeof(size_t));
+      w.Write(&size, sizeof(uint32_t));
       w.Write(neighbor.c_str(), neighbor.size());
     }
   }
@@ -118,7 +121,7 @@ public:
 
   void reserveAdjacencyMatrix() {m_adjacencyMatrix.resize(m_ingoingNodes.size() * m_outgoingNodes.size());}
 
-  void setAdjacencyCost(std::vector<size_t>::const_iterator ingoing_iter, std::vector<std::pair<size_t,size_t>>::const_iterator outgoin_iter, int value)
+  void setAdjacencyCost(std::vector<uint32_t>::const_iterator ingoing_iter, std::vector<std::pair<uint32_t,uint32_t>>::const_iterator outgoin_iter, WritedEdgeWeight value)
   {
     size_t ingoing_index = std::distance(m_ingoingNodes.cbegin(), ingoing_iter);
     size_t outgoing_index = std::distance(m_outgoingNodes.cbegin(), outgoin_iter);
diff --git a/routing/osrm_router.cpp b/routing/osrm_router.cpp
index a84428c611..d96ad9a025 100644
--- a/routing/osrm_router.cpp
+++ b/routing/osrm_router.cpp
@@ -341,13 +341,18 @@ public:
 
 
 
-RoutingMapping::RoutingMapping(string const & fName, Index const * pIndex): m_mapCounter(0), m_facadeCounter(0), m_baseName(fName)
+RoutingMapping::RoutingMapping(string const & fName, Index const * pIndex): m_mapCounter(0), m_facadeCounter(0), m_baseName(fName),
+                                                                            m_isValid(true), m_error(IRouter::ResultCode::NoError)
 {
   Platform & pl = GetPlatform();
   string const mwmName = m_baseName + DATA_FILE_EXTENSION;
   string const fPath = pl.WritablePathForFile(mwmName + ROUTING_FILE_EXTENSION);
   if (!pl.IsFileExistsByFullPath(fPath))
-    throw IRouter::ResultCode::RouteFileNotExist;
+  {
+    m_isValid = false;
+    m_error = IRouter::ResultCode::RouteFileNotExist;
+    return;
+  }
   // Open new container and check that mwm and routing have equal timestamp.
   LOG(LDEBUG, ("Load routing index for file:", fPath));
   m_container.Open(fPath);
@@ -360,7 +365,9 @@ RoutingMapping::RoutingMapping(string const & fName, Index const * pIndex): m_ma
     if (ver::ReadTimestamp(src1) != ver::ReadTimestamp(src2))
     {
       m_container.Close();
-      throw IRouter::ResultCode::InconsistentMWMandRoute;
+      m_isValid = false;
+      m_error = IRouter::ResultCode::InconsistentMWMandRoute;
+      return;
     }
     m_segMapping.Load(m_container);
   }
@@ -370,9 +377,12 @@ RoutingMapping::RoutingMapping(string const & fName, Index const * pIndex): m_ma
 
 OsrmRouter::OsrmRouter(Index const * index, CountryFileFnT const & fn)
   : m_pIndex(index), m_indexManager(fn), m_isFinalChanged(false),
-    m_requestCancel(false)
+    m_requestCancel(false), m_additionalFeatures(false)
 {
   m_isReadyThread.clear();
+#ifdef DEBUG
+  m_additionalFeatures = true;
+#endif
 }
 
 string OsrmRouter::GetName() const
@@ -596,6 +606,7 @@ bool OsrmRouter::FindSingleRoute(FeatureGraphNodeVecT const & source, FeatureGra
 
 m2::PointD OsrmRouter::GetPointByNodeId(const size_t node_id, RoutingMappingPtrT const & routingMapping, bool use_start)
 {
+  ASSERT(routingMapping.get()!=nullptr, ());
   auto nSegs = routingMapping->m_segMapping.GetSegmentsRange(node_id);
 
   ASSERT_GREATER(nSegs.second, 0, ());
@@ -684,6 +695,7 @@ OsrmRouter::ResultCode OsrmRouter::MakeRouteFromCrossesPath(CheckedPathT const &
     }
     RoutingMappingPtrT mwmMapping;
     mwmMapping = m_indexManager.GetMappingByName(cross.mwmName, m_pIndex);
+    ASSERT(mwmMapping->IsValid(), ());
     mwmMapping->LoadFacade();
     if (!FindSingleRoute(startTask, targetTask, mwmMapping->m_dataFacade, routingResult))
     {
@@ -801,6 +813,11 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
   RoutingMappingPtrT startMapping = m_indexManager.GetMappingByPoint(startPt, m_pIndex);
   RoutingMappingPtrT targetMapping = m_indexManager.GetMappingByPoint(finalPt, m_pIndex);
 
+  if (!startMapping->IsValid())
+    return startMapping->GetError();
+  if (!targetMapping->IsValid())
+    return targetMapping->GetError();
+
   MappingGuard startMappingGuard(startMapping);
   MappingGuard finalMappingGuard(targetMapping);
   UNUSED_VALUE(startMappingGuard);
@@ -861,6 +878,8 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
   else //4.2 Different mwm case
   {
     LOG(LINFO, ("Different mwm routing case"));
+    if (!m_additionalFeatures)
+      return PointsInDifferentMWM;
 
     // Load source data
     CrossRoutingContext const & startContext = startMapping->m_dataFacade.getRoutingContext();
@@ -882,7 +901,7 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
     if (m_requestCancel)
       return Cancelled;
 
-    //Load target data
+    // Load target data
     LastCrossFinder targetFinder(targetMapping, m_CachedTargetTask);
 
     EdgeWeight finalWeight = INVALID_EDGE_WEIGHT;
@@ -900,14 +919,10 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
           return Cancelled;
         string const & nextMwm = startContext.getOutgoingMwmName((out_iterators.first+j)->second);
         RoutingMappingPtrT nextMapping;
-        try
-        {
-          nextMapping = m_indexManager.GetMappingByName(nextMwm, m_pIndex);
-        }
-        catch (OsrmRouter::ResultCode e)
-        {
-          continue; //There is no outgoing mwm
-        }
+        nextMapping = m_indexManager.GetMappingByName(nextMwm, m_pIndex);
+        // If we don't this routing file, we skip this path
+        if (!nextMapping->IsValid())
+          continue;
         MappingGuard nextMappingGuard(nextMapping);
         UNUSED_VALUE(nextMappingGuard);
         size_t tNodeId = (out_iterators.first+j)->first;
@@ -952,25 +967,21 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
         crossTasks.pop();
         RoutePathCross const cross = topTask.back();
         RoutingMappingPtrT currentMapping;
-        try
-        {
-          currentMapping = m_indexManager.GetMappingByName(cross.mwmName, m_pIndex);
-        }
-        catch (OsrmRouter::ResultCode e)
-        {
-          continue; //There is no outgoing mwm
-        }
+
+        currentMapping = m_indexManager.GetMappingByName(cross.mwmName, m_pIndex);
+        ASSERT(currentMapping->IsValid(), ("We have what we test!"));
+
         MappingGuard currentMappingGuard(currentMapping);
         UNUSED_VALUE(currentMappingGuard);
         CrossRoutingContext const & currentContext = currentMapping->m_dataFacade.getRoutingContext();
         auto current_in_iterators = currentContext.GetIngoingIterators();
         auto current_out_iterators = currentContext.GetOutgoingIterators();
 
-        //find income number
+        // find income number
         auto const iit = find(current_in_iterators.first, current_in_iterators.second, cross.startNode.m_node.forward_node_id);
         ASSERT(iit != current_in_iterators.second, ());
 
-        //find outs
+        // find outs
         for (auto oit = current_out_iterators.first; oit != current_out_iterators.second; ++oit)
         {
           const EdgeWeight outWeight = currentContext.getAdjacencyCost(iit, oit);
@@ -982,14 +993,10 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
                 return Cancelled;
               string const & nextMwm = currentContext.getOutgoingMwmName(oit->second);
               RoutingMappingPtrT nextMapping;
-              try
-              {
-                nextMapping = m_indexManager.GetMappingByName(nextMwm, m_pIndex);
-              }
-              catch (OsrmRouter::ResultCode e)
-              {
-                continue; //There is no outgoing mwm
-              }
+
+              nextMapping = m_indexManager.GetMappingByName(nextMwm, m_pIndex);
+              if (!nextMapping->IsValid())
+                continue;
 
               MappingGuard nextMappingGuard(nextMapping);
               UNUSED_VALUE(nextMappingGuard);
@@ -1199,14 +1206,14 @@ OsrmRouter::ResultCode OsrmRouter::MakeTurnAnnotation(RawRoutingResultT const &
     }
   }
 
+  if (points.size() < 2)
+    return RouteNotFound;
+
   if (routingResult.m_sourceEdge.m_seg.IsValid())
     points.front() = routingResult.m_sourceEdge.m_segPt;
   if (routingResult.m_targetEdge.m_seg.IsValid())
     points.back() = routingResult.m_targetEdge.m_segPt;
 
-  if (points.size() < 2)
-    return RouteNotFound;
-
   times.push_back(Route::TimeItemT(points.size() - 1, estimateTime));
   if (routingResult.m_targetEdge.m_seg.IsValid())
     turnsDir.push_back(Route::TurnItem(points.size() - 1, turns::ReachedYourDestination));
@@ -1291,7 +1298,7 @@ void OsrmRouter::GetPossibleTurns(NodeID node,
                                   RoutingMappingPtrT const & routingMapping,
                                   OsrmRouter::TurnCandidatesT & candidates)
 {
-
+  ASSERT(routingMapping.get()!=nullptr, ());
   for (EdgeID e : routingMapping->m_dataFacade.GetAdjacentEdgeRange(node))
   {
     QueryEdge::EdgeData const data = routingMapping->m_dataFacade.GetEdgeData(e, node);
@@ -1338,6 +1345,7 @@ void OsrmRouter::GetPossibleTurns(NodeID node,
 void OsrmRouter::GetTurnGeometry(m2::PointD const & p, m2::PointD const & p1,
                                  OsrmRouter::GeomTurnCandidateT & candidates, RoutingMappingPtrT const & mapping) const
 {
+  ASSERT(mapping.get()!=nullptr, ());
   Point2Geometry getter(p, p1, candidates);
   m_pIndex->ForEachInRectForMWM(getter, MercatorBounds::RectByCenterXYAndSizeInMeters(p, FEATURES_NEAR_TURN_M),
                                 scales::GetUpperScale(), mapping->GetMwmId());
@@ -1425,6 +1433,7 @@ turns::TurnDirection OsrmRouter::IntermediateDirection(const double angle) const
 bool OsrmRouter::KeepOnewayOutgoingTurnIncomingEdges(TurnCandidatesT const & nodes, Route::TurnItem const & turn,
                             m2::PointD const & p, m2::PointD const & p1OneSeg, RoutingMappingPtrT const & mapping) const
 {
+  ASSERT(mapping.get()!=nullptr, ());
   size_t const outgoingNotesCount = 1;
   if (turns::IsGoStraightOrSlightTurn(turn.m_turn))
     return false;
@@ -1468,6 +1477,7 @@ void OsrmRouter::GetTurnDirection(PathData const & node1,
                                   PathData const & node2,
                                   RoutingMappingPtrT const & routingMapping, Route::TurnItem & turn)
 {
+  ASSERT(routingMapping.get() != nullptr, ());
   auto nSegs1 = routingMapping->m_segMapping.GetSegmentsRange(node1.node);
   auto nSegs2 = routingMapping->m_segMapping.GetSegmentsRange(node2.node);
 
diff --git a/routing/osrm_router.hpp b/routing/osrm_router.hpp
index cd84e86b9b..4a4d9ad185 100644
--- a/routing/osrm_router.hpp
+++ b/routing/osrm_router.hpp
@@ -29,7 +29,7 @@ typedef function<string (m2::PointD const &)> CountryFileFnT;
 typedef OsrmRawDataFacade<QueryEdge::EdgeData> RawDataFacadeT;
 typedef OsrmDataFacade<QueryEdge::EdgeData> DataFacadeT;
 
-///Single graph node representation for routing task
+/// Single graph node representation for routing task
 struct FeatureGraphNode
 {
   PhantomNode m_node;
@@ -57,7 +57,7 @@ struct RawRoutingResultT
 typedef vector<RawRoutingResultT> MultipleRoutingResultT;
 
 
-///Datamapping and facade for single MWM and MWM.routing file
+/// Datamapping and facade for single MWM and MWM.routing file
 struct RoutingMapping
 {
   DataFacadeT m_dataFacade;
@@ -102,6 +102,10 @@ struct RoutingMapping
       m_dataFacade.Clear();
   }
 
+  bool IsValid() {return m_isValid;}
+
+  IRouter::ResultCode GetError() {return m_error;}
+
   string GetName() {return m_baseName;}
 
   Index::MwmId GetMwmId() {return m_mwmId;}
@@ -112,6 +116,8 @@ private:
   string m_baseName;
   FilesMappingContainer m_container;
   Index::MwmId m_mwmId;
+  bool m_isValid;
+  IRouter::ResultCode m_error;
 };
 
 typedef shared_ptr<RoutingMapping> RoutingMappingPtrT;
@@ -155,12 +161,12 @@ public:
 
   RoutingMappingPtrT GetMappingByName(string const & fName, Index const * pIndex)
   {
-    //Check if we have already load this file
+    // Check if we have already load this file
     auto mapIter = m_mapping.find(fName);
     if (mapIter != m_mapping.end())
       return mapIter->second;
     //Or load and check file
-    RoutingMappingPtrT new_mapping = RoutingMappingPtrT(new RoutingMapping(fName, pIndex));
+    RoutingMappingPtrT new_mapping = make_shared<RoutingMapping>(fName, pIndex);
 
     m_mapping.insert(std::make_pair(fName, new_mapping));
     return new_mapping;
@@ -209,7 +215,7 @@ public:
    * \return true if path exists. False otherwise
    */
   static bool FindSingleRoute(FeatureGraphNodeVecT const & source, FeatureGraphNodeVecT const & target, DataFacadeT & facade,
-                       RawRoutingResultT& rawRoutingResult);
+                       RawRoutingResultT & rawRoutingResult);
 
   /*!
    * \brief FindCostMatrix Find costs matrix from sources to targets. WARNING in finds only costs of shortests, not pathes.
@@ -219,7 +225,7 @@ public:
    * \param result vector with result costs. Packed. Source nodes are rows. S1T1 S1T2 S2T1 S2T2
    */
   static void FindWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
-                                      RawDataFacadeT &facade, std::vector<EdgeWeight> &result);
+                                      RawDataFacadeT & facade, std::vector<EdgeWeight> & result);
 
   /*!
    * \brief GenerateRoutingTaskFromNodeId fill taskNode with values for making route
@@ -228,6 +234,8 @@ public:
    */
   static void GenerateRoutingTaskFromNodeId(const size_t nodeId, FeatureGraphNode & taskNode);
 
+  void ActivateAdditionalFeatures() {m_additionalFeatures = true;}
+
 protected:
   IRouter::ResultCode FindPhantomNodes(string const & fName, m2::PointD const & point, m2::PointD const & direction,
                                        FeatureGraphNodeVecT & res, size_t maxCount, RoutingMappingPtrT const  & mapping);
@@ -285,7 +293,7 @@ private:
   typedef priority_queue<CheckedPathT, vector<CheckedPathT>, pathChecker> RoutingTaskQueueT;
 
   MultiroutingTaskPointT::const_iterator FilterWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
-                                      std::vector<EdgeWeight> &weightMatrix);
+                                      std::vector<EdgeWeight> & weightMatrix);
 
   /*!
    * \brief Makes route (points turns and other annotations) and submits it to @route class
@@ -306,8 +314,8 @@ private:
                         Route::TurnItem & turn);
   void CalculateTurnGeometry(vector<m2::PointD> const & points, Route::TurnsT const & turnsDir, turns::TurnsGeomT & turnsGeom) const;
   void FixupTurns(vector<m2::PointD> const & points, Route::TurnsT & turnsDir) const;
-  m2::PointD GetPointForTurnAngle(OsrmFtSegMapping::FtSeg const &seg,
-                                  FeatureType const &ft, m2::PointD const &turnPnt,
+  m2::PointD GetPointForTurnAngle(OsrmFtSegMapping::FtSeg const & seg,
+                                  FeatureType const & ft, m2::PointD const & turnPnt,
                                   size_t (*GetPndInd)(const size_t, const size_t, const size_t)) const;
   turns::TurnDirection InvertDirection(turns::TurnDirection dir) const;
   turns::TurnDirection MostRightDirection(double angle) const;
@@ -339,6 +347,9 @@ private:
   atomic_flag m_isReadyThread;
 
   volatile bool m_requestCancel;
+
+  // Additional features unlocking engine
+  bool m_additionalFeatures;
 };
 
 }
diff --git a/routing/router.hpp b/routing/router.hpp
index 65b60c1d37..33a6019cd7 100644
--- a/routing/router.hpp
+++ b/routing/router.hpp
@@ -36,6 +36,7 @@ public:
   virtual string GetName() const = 0;
 
   virtual void ClearState() {}
+  virtual void ActivateAdditionalFeatures() {}
 
   virtual void SetFinalPoint(m2::PointD const & finalPt) = 0;
   virtual void CalculateRoute(m2::PointD const & startingPt, ReadyCallback const & callback, m2::PointD const & direction = m2::PointD::Zero()) = 0;
diff --git a/routing/routing_tests/routing_tests.pro b/routing/routing_tests/routing_tests.pro
index 08ee21dab2..2a3e06618a 100644
--- a/routing/routing_tests/routing_tests.pro
+++ b/routing/routing_tests/routing_tests.pro
@@ -21,5 +21,5 @@ SOURCES += \
   ../../testing/testingmain.cpp \
   osrm_router_test.cpp \
   vehicle_model_test.cpp \
-    cross_routing_tests.cpp \
+  cross_routing_tests.cpp \