diff --git a/coding/files_container.cpp b/coding/files_container.cpp
index 1b639e6128..d8960c70a9 100644
--- a/coding/files_container.cpp
+++ b/coding/files_container.cpp
@@ -256,7 +256,7 @@ FileReader FilesMappingContainer::GetReader(Tag const & tag) const
 // FilesMappingContainer::Handle
 /////////////////////////////////////////////////////////////////////////////
 
-FilesMappingContainer::Handle::~Handle()
+detail::MappedFile::Handle::~Handle()
 {
   Unmap();
 }
diff --git a/generator/collector_camera.cpp b/generator/collector_camera.cpp
index 7fe949e1cf..2c65ba5a41 100644
--- a/generator/collector_camera.cpp
+++ b/generator/collector_camera.cpp
@@ -170,39 +170,17 @@ void CameraProcessor::Save(std::string const & filename)
 
 void CameraProcessor::OrderCollectedData(std::string const & filename)
 {
+  std::vector<CameraProcessor::CameraInfo> collectedData;
   {
-    std::vector<CameraProcessor::CameraInfo> collectedData;
-    {
-      FileReader reader(filename);
-      ReaderSource src(reader);
-      while (src.Size() > 0)
-        collectedData.emplace_back(CameraInfo::Read(src));
-    }
-    std::sort(std::begin(collectedData), std::end(collectedData));
-    FileWriter writer(filename);
-    for (auto const & camera : collectedData)
-      CameraInfo::Write(writer, camera);
-  }
-  {
-    std::vector<std::pair<uint64_t, std::vector<uint64_t>>> collectedData;
-    {
-      FileReader reader(m_waysFilename);
-      ReaderSource src(reader);
-      while (src.Size() > 0)
-      {
-        collectedData.push_back({});
-        src.Read(&collectedData.back().first, sizeof(collectedData.back().first));
-        rw::ReadVectorOfPOD(src, collectedData.back().second);
-      }
-    }
-    std::sort(std::begin(collectedData), std::end(collectedData));
-    FileWriter writer(m_waysFilename);
-    for (auto const & p : collectedData)
-    {
-      WriteToSink(writer, p.first);
-      rw::WriteVectorOfPOD(writer, p.second);
-    }
+    FileReader reader(filename);
+    ReaderSource src(reader);
+    while (src.Size() > 0)
+      collectedData.emplace_back(CameraInfo::Read(src));
   }
+  std::sort(std::begin(collectedData), std::end(collectedData));
+  FileWriter writer(filename);
+  for (auto const & camera : collectedData)
+    CameraInfo::Write(writer, camera);
 }
 
 CameraCollector::CameraCollector(std::string const & filename) :
diff --git a/generator/generator_tests/road_access_test.cpp b/generator/generator_tests/road_access_test.cpp
index 611e3499ae..a0a0d0a5f8 100644
--- a/generator/generator_tests/road_access_test.cpp
+++ b/generator/generator_tests/road_access_test.cpp
@@ -26,6 +26,7 @@
 #include "base/scope_guard.hpp"
 #include "base/string_utils.hpp"
 
+#include <iterator>
 #include <map>
 #include <string>
 #include <vector>
@@ -63,37 +64,6 @@ void BuildTestMwmWithRoads(LocalCountryFile & country)
   }
 }
 
-size_t GetLinesNumber(string const & text)
-{
-  stringstream ss;
-  ss << text.data();
-  string line;
-  size_t n = 0;
-  while (getline(ss, line))
-    ++n;
-  return n;
-}
-
-bool ExistsConsecutiveLines(string const & text, vector<string> const & lines)
-{
-  stringstream ss;
-  ss << text.data();
-  size_t lineIndex = 0;
-  string lineFromText;
-  while (getline(ss, lineFromText))
-  {
-    if (lineFromText == lines[lineIndex])
-      ++lineIndex;
-    else
-      lineIndex = 0;
-
-    if (lineIndex == lines.size())
-      return true;
-  }
-
-  return false;
-}
-
 void LoadRoadAccess(string const & mwmFilePath, VehicleType vehicleType, RoadAccess & roadAccess)
 {
   FilesContainerR const cont(mwmFilePath);
@@ -392,37 +362,19 @@ UNIT_TEST(RoadAccessWriter_ConditionalMerge)
   c1->Merge(*c2);
   c1->Merge(*c3);
 
-  c1->Finalize();
+  c1->Finalize(true /*isStable*/);
 
   ifstream stream;
   stream.exceptions(fstream::failbit | fstream::badbit);
   stream.open(filename + ROAD_ACCESS_CONDITIONAL_EXT);
-  stringstream buffer;
-  buffer << stream.rdbuf();
+  string const resultFile((istreambuf_iterator<char>(stream)), istreambuf_iterator<char>());
 
-  size_t linesNumber = 0;
-  auto const test = [&linesNumber, &buffer](vector<string> const & lines) {
-    TEST(ExistsConsecutiveLines(buffer.str(), lines), (buffer.str(), lines));
-    linesNumber += lines.size();
-  };
+  string const expectedFile =
+      "Car\t1\t1\tNo\tMo-Su\t\n"
+      "Car\t2\t1\tPrivate\t10:00-20:00\t\n"
+      "Car\t3\t2\tPrivate\t12:00-19:00\tNo\tMo-Su\t\n";
 
-  test({"Car 3 2",
-        "Private",
-        "12:00-19:00",
-        "No",
-        "Mo-Su"});
-
-  test({
-      "Car 2 1",
-      "Private",
-      "10:00-20:00"});
-
-  test({
-      "Car 1 1",
-      "No",
-      "Mo-Su"});
-
-  TEST_EQUAL(GetLinesNumber(buffer.str()), linesNumber, ());
+  TEST_EQUAL(resultFile, expectedFile, ());
 }
 
 UNIT_TEST(RoadAccessWriter_Conditional_WinterRoads)
@@ -446,39 +398,21 @@ UNIT_TEST(RoadAccessWriter_Conditional_WinterRoads)
   c1->CollectFeature(MakeFbForTest(w2), w2);
 
   c1->Finish();
-  c1->Finalize();
+  c1->Finalize(true /*isStable*/);
 
   ifstream stream;
   stream.exceptions(fstream::failbit | fstream::badbit);
   stream.open(filename + ROAD_ACCESS_CONDITIONAL_EXT);
-  stringstream buffer;
-  buffer << stream.rdbuf();
+  string const resultFile((istreambuf_iterator<char>(stream)), istreambuf_iterator<char>());
 
-  size_t linesNumber = 0;
-  auto const test = [&linesNumber, &buffer](vector<string> const & lines) {
-    TEST(ExistsConsecutiveLines(buffer.str(), lines), (buffer.str(), lines));
-    linesNumber += lines.size();
-  };
+  string const expectedFile =
+      "Bicycle\t1\t1\tNo\tMar - Nov\t\n"
+      "Bicycle\t2\t1\tNo\tMar - Nov\t\n"
+      "Car\t1\t1\tNo\tMar - Nov\t\n"
+      "Car\t2\t1\tNo\tMar - Nov\t\n"
+      "Pedestrian\t1\t1\tNo\tMar - Nov\t\n"
+      "Pedestrian\t2\t1\tNo\tMar - Nov\t\n";
 
-  test({"Pedestrian 2 1",
-        "No",
-        "Mar - Nov"});
-  test({"Pedestrian 1 1",
-        "No",
-        "Mar - Nov"});
-  test({"Bicycle 2 1",
-        "No",
-        "Mar - Nov"});
-  test({"Bicycle 1 1",
-        "No",
-        "Mar - Nov"});
-  test({"Car 2 1",
-        "No",
-        "Mar - Nov"});
-  test({"Car 1 1",
-        "No",
-        "Mar - Nov"});
-
-  TEST_EQUAL(GetLinesNumber(buffer.str()), linesNumber, ());
+  TEST_EQUAL(resultFile, expectedFile, ());
 }
 }  // namespace
diff --git a/generator/metalines_builder.cpp b/generator/metalines_builder.cpp
index 707819a812..421e9ac680 100644
--- a/generator/metalines_builder.cpp
+++ b/generator/metalines_builder.cpp
@@ -164,7 +164,10 @@ LineStringMerger::OutputData LineStringMerger::OrderData(InputData const & data)
 
 // MetalinesBuilder --------------------------------------------------------------------------------
 MetalinesBuilder::MetalinesBuilder(std::string const & filename)
-  : generator::CollectorInterface(filename) {}
+  : generator::CollectorInterface(filename)
+  , m_writer(std::make_unique<FileWriter>(GetTmpFilename()))
+{
+}
 
 std::shared_ptr<generator::CollectorInterface> MetalinesBuilder::Clone(
     std::shared_ptr<generator::cache::IntermediateDataReaderInterface> const &) const
@@ -186,16 +189,28 @@ void MetalinesBuilder::CollectFeature(FeatureBuilder const & feature, OsmElement
   if (name.empty() && params.ref.empty())
     return;
 
-  auto const key = std::hash<std::string>{}(name + '\0' + params.ref);
-  m_data.emplace(key, std::make_shared<LineString>(element));
+  auto const key = static_cast<uint64_t>(std::hash<std::string>{}(name + '\0' + params.ref));
+  WriteVarUint(*m_writer, key);
+  LineString(element).Serialize(*m_writer);
 }
 
+void MetalinesBuilder::Finish() { m_writer.reset(); }
+
 void MetalinesBuilder::Save()
 {
+  std::unordered_multimap<size_t, std::shared_ptr<LineString>> keyToLineString;
+  FileReader reader(GetTmpFilename());
+  ReaderSource<FileReader> src(reader);
+  while (src.Size() > 0)
+  {
+    auto const key = ReadVarUint<uint64_t>(src);
+    keyToLineString.emplace(key, std::make_shared<LineString>(LineString::Deserialize(src)));
+  }
+
   FileWriter writer(GetFilename());
   uint32_t countLines = 0;
   uint32_t countWays = 0;
-  auto const mergedData = LineStringMerger::Merge(m_data);
+  auto const mergedData = LineStringMerger::Merge(keyToLineString);
   for (auto const & p : mergedData)
   {
     for (auto const & lineString : p.second)
@@ -236,7 +251,8 @@ void MetalinesBuilder::Merge(generator::CollectorInterface const & collector)
 
 void MetalinesBuilder::MergeInto(MetalinesBuilder & collector) const
 {
-  collector.m_data.insert(std::begin(m_data), std::end(m_data));
+  CHECK(!m_writer || !collector.m_writer, ("Finish() has not been called."));
+  base::AppendFileToFile(GetTmpFilename(), collector.GetTmpFilename());
 }
 
 // Functions --------------------------------------------------------------------------------
diff --git a/generator/metalines_builder.hpp b/generator/metalines_builder.hpp
index 8fd89af7f1..43c4c2fba6 100644
--- a/generator/metalines_builder.hpp
+++ b/generator/metalines_builder.hpp
@@ -4,6 +4,10 @@
 #include "generator/feature_builder.hpp"
 #include "generator/osm_element.hpp"
 
+#include "coding/reader.hpp"
+#include "coding/write_to_sink.hpp"
+#include "coding/writer.hpp"
+
 #include <cstdlib>
 #include <cstdint>
 #include <map>
@@ -37,7 +41,29 @@ public:
   uint64_t GetStart() const { return m_start; }
   uint64_t GetEnd() const { return m_end; }
 
+  template <typename T>
+  void Serialize(T & w)
+  {
+    WriteVarUint(w, m_start);
+    WriteVarUint(w, m_end);
+    WriteToSink(w, m_oneway);
+    rw::WriteVectorOfPOD(w, m_ways);
+  }
+
+  template <typename T>
+  static LineString Deserialize(T & r)
+  {
+    LineString ls;
+    ls.m_start = ReadVarUint<uint64_t>(r);
+    ls.m_end = ReadVarUint<uint64_t>(r);
+    ReadPrimitiveFromSource(r, ls.m_oneway);
+    rw::ReadVectorOfPOD(r, ls.m_ways);
+    return ls;
+  }
+
 private:
+  LineString() = default;
+
   uint64_t m_start;
   uint64_t m_end;
   bool m_oneway;
@@ -75,6 +101,8 @@ public:
   /// Add a highway segment to the collection of metalines.
   void CollectFeature(FeatureBuilder const & feature, OsmElement const & element) override;
 
+  void Finish() override;
+
   void Merge(generator::CollectorInterface const & collector) override;
   void MergeInto(MetalinesBuilder & collector) const override;
 
@@ -83,7 +111,7 @@ protected:
   void OrderCollectedData() override;
 
 private:
-  std::unordered_multimap<size_t, std::shared_ptr<LineString>> m_data;
+  std::unique_ptr<FileWriter> m_writer;
 };
 
 // Read an intermediate file from MetalinesBuilder and convert it to an mwm section.
diff --git a/generator/road_access_generator.cpp b/generator/road_access_generator.cpp
index 856ceb1123..72167358d7 100644
--- a/generator/road_access_generator.cpp
+++ b/generator/road_access_generator.cpp
@@ -285,30 +285,30 @@ void ParseRoadAccessConditional(
   VehicleType vehicleType = VehicleType::Count;
   while (getline(stream, line))
   {
-    using It = strings::SimpleTokenizer;
+    using It = strings::SimpleTokenizerWithEmptyTokens;
     It strIt(line, strings::SimpleDelimiter('\t'));
-    CHECK(strIt, ());
+    CHECK(strIt, (line));
     buffer = *strIt;
     strings::Trim(buffer);
     FromString(buffer, vehicleType);
-    CHECK_NOT_EQUAL(vehicleType, VehicleType::Count, (buffer));
+    CHECK_NOT_EQUAL(vehicleType, VehicleType::Count, (line, buffer));
 
     auto const moveIterAndCheck = [&]() {
       ++strIt;
-      CHECK(strIt, ());
+      CHECK(strIt, (line));
       return *strIt;
     };
 
     uint64_t osmId = 0;
     buffer = moveIterAndCheck();
     strings::Trim(buffer);
-    CHECK(strings::to_uint64(buffer, osmId), (buffer));
+    CHECK(strings::to_uint64(buffer, osmId), (line, buffer));
 
     size_t accessNumber = 0;
     buffer = moveIterAndCheck();
     strings::Trim(buffer);
-    CHECK(strings::to_size_t(buffer, accessNumber), (buffer));
-    CHECK_NOT_EQUAL(accessNumber, 0, ());
+    CHECK(strings::to_size_t(buffer, accessNumber), (line, buffer));
+    CHECK_NOT_EQUAL(accessNumber, 0, (line));
     RoadAccess::Conditional conditional;
     for (size_t i = 0; i < accessNumber; ++i)
     {
@@ -316,7 +316,7 @@ void ParseRoadAccessConditional(
       strings::Trim(buffer);
       RoadAccess::Type roadAccessType = RoadAccess::Type::Count;
       FromString(buffer, roadAccessType);
-      CHECK_NOT_EQUAL(roadAccessType, RoadAccess::Type::Count, ());
+      CHECK_NOT_EQUAL(roadAccessType, RoadAccess::Type::Count, (line));
 
       buffer = moveIterAndCheck();
       strings::Trim(buffer);
diff --git a/generator/world_roads_builder/world_roads_builder_tool/world_roads_builder_tool.cpp b/generator/world_roads_builder/world_roads_builder_tool/world_roads_builder_tool.cpp
index 3c89b5cd2e..03a7c0702d 100644
--- a/generator/world_roads_builder/world_roads_builder_tool/world_roads_builder_tool.cpp
+++ b/generator/world_roads_builder/world_roads_builder_tool/world_roads_builder_tool.cpp
@@ -47,6 +47,7 @@ int main(int argc, char ** argv)
   feature::CountriesFilesAffiliation mwmMatcher(GetPlatform().ResourcesDir(),
                                                 false /* haveBordersForWholeWorld */);
 
+  // These types are used in maps_generator (maps_generator/genrator/steps.py in filter_roads function).
   std::vector<std::string> const highwayTypes{"motorway", "trunk", "primary", "secondary",
                                               "tertiary"};
 
diff --git a/search/ranking_info.cpp b/search/ranking_info.cpp
index a2bff174b7..b08b3aaf76 100644
--- a/search/ranking_info.cpp
+++ b/search/ranking_info.cpp
@@ -258,7 +258,10 @@ double RankingInfo::GetLinearModelRank() const
     result += m_falseCats * kFalseCats;
     result += kType[m_type];
     if (Model::IsPoi(m_type))
+    {
+      CHECK_NOT_EQUAL(m_resultType, ResultType::Count, ());
       result += kResultType[base::Underlying(m_resultType)];
+    }
     result += (m_allTokensUsed ? 1 : 0) * kAllTokensUsed;
     result += (m_exactCountryOrCapital ? 1 : 0) * kExactCountryOrCapital;
     auto const nameRank = kNameScore[nameScore] + kErrorsMade * GetErrorsMadePerToken() +
diff --git a/search/search_tests/ranking_tests.cpp b/search/search_tests/ranking_tests.cpp
index 3d39dd77a5..86a97b58d1 100644
--- a/search/search_tests/ranking_tests.cpp
+++ b/search/search_tests/ranking_tests.cpp
@@ -86,6 +86,7 @@ UNIT_TEST(PreferCountry)
   cafe.m_tokenRanges[Model::TYPE_SUBPOI] = TokenRange(0, 1);
   cafe.m_exactCountryOrCapital = false;
   cafe.m_type = Model::TYPE_SUBPOI;
+  cafe.m_resultType = ResultType::Eat;
 
   auto country = info;
   country.m_distanceToPivot = 1e6;
diff --git a/skin_generator/generator.cpp b/skin_generator/generator.cpp
index 96827a485e..dd65107aeb 100644
--- a/skin_generator/generator.cpp
+++ b/skin_generator/generator.cpp
@@ -68,7 +68,7 @@ void SkinGenerator::ProcessSymbols(std::string const & svgDataDir,
     QDir dir(QString(svgDataDir.c_str()));
     QStringList fileNames = dir.entryList(QDir::Files);
 
-    QDir pngDir = dir.absolutePath() + "/png";
+    QDir pngDir(dir.absolutePath() + "/png");
     fileNames += pngDir.entryList(QDir::Files);
 
     // Separate page for symbols.
diff --git a/tools/python/maps_generator/generator/steps.py b/tools/python/maps_generator/generator/steps.py
index ceb27a79d2..e58cccc25f 100644
--- a/tools/python/maps_generator/generator/steps.py
+++ b/tools/python/maps_generator/generator/steps.py
@@ -216,7 +216,7 @@ def filter_roads(
         output=output,
         error=error,
         keep="",
-        keep_ways="highway=*",
+        keep_ways="highway=motorway =trunk =primary =secondary =tertiary",
     )
 
 
diff --git a/transit/world_feed/feed_helpers.cpp b/transit/world_feed/feed_helpers.cpp
index f88299d7ad..d51c01b6f2 100644
--- a/transit/world_feed/feed_helpers.cpp
+++ b/transit/world_feed/feed_helpers.cpp
@@ -22,23 +22,25 @@ struct ProjectionData
   size_t m_indexOnShape = 0;
   // Distance from point to its projection.
   double m_distFromPoint = 0.0;
-  // Distance from start point on polyline to the projection.
-  double m_distFromStart = 0.0;
+  // Distance from the first ending (start for forward direction, end for backward) point on
+  // polyline to the projection.
+  double m_distFromEnding = 0.0;
   // Point on polyline almost equal to the projection can already exist, so we don't need to
   // insert projection. Or we insert it to the polyline.
   bool m_needsInsertion = false;
 };
 
-// Returns true if |p1| is much closer to start then |p2| (parameter |distDeltaStart|) and its
-// distance to projections to polyline |m_distFromPoint| is comparable.
-bool CloserToStartAndOnSimilarDistToLine(ProjectionData const & p1, ProjectionData const & p2)
+// Returns true if |p1| is much closer to the first ending (start for forward direction, end for
+// backward) then |p2| (parameter |distDeltaEnding|) and its distance to projections to polyline
+// |m_distFromPoint| is comparable.
+bool CloserToEndingAndOnSimilarDistToLine(ProjectionData const & p1, ProjectionData const & p2)
 {
   // Delta between two points distances from start point on polyline.
   double constexpr distDeltaStart = 100.0;
   // Delta between two points distances from their corresponding projections to polyline.
   double constexpr distDeltaProj = 90.0;
 
-  return (p1.m_distFromStart + distDeltaStart < p2.m_distFromStart &&
+  return (p1.m_distFromEnding + distDeltaStart < p2.m_distFromEnding &&
           std::abs(p2.m_distFromPoint - p1.m_distFromPoint) <= distDeltaProj);
 }
 }  // namespace
@@ -55,25 +57,29 @@ ProjectionToShape ProjectStopOnTrack(m2::PointD const & stopPoint, m2::PointD co
 }
 
 ProjectionData GetProjection(std::vector<m2::PointD> const & polyline, size_t index,
-                             ProjectionToShape const & proj)
+                             Direction direction, ProjectionToShape const & proj)
 {
   ProjectionData projData;
   projData.m_distFromPoint = proj.m_dist;
   projData.m_proj = proj.m_point;
 
+  auto const next = direction == Direction::Forward ? index + 1 : index - 1;
+  CHECK_GREATER_OR_EQUAL(next, 0, ());
+  CHECK_LESS(next, polyline.size(), ());
+
   if (base::AlmostEqualAbs(proj.m_point, polyline[index], kEps))
   {
     projData.m_indexOnShape = index;
     projData.m_needsInsertion = false;
   }
-  else if (base::AlmostEqualAbs(proj.m_point, polyline[index + 1], kEps))
+  else if (base::AlmostEqualAbs(proj.m_point, polyline[next], kEps))
   {
-    projData.m_indexOnShape = index + 1;
+    projData.m_indexOnShape = next;
     projData.m_needsInsertion = false;
   }
   else
   {
-    projData.m_indexOnShape = index + 1;
+    projData.m_indexOnShape = direction == Direction::Forward ? next : index;
     projData.m_needsInsertion = true;
   }
 
@@ -81,24 +87,44 @@ ProjectionData GetProjection(std::vector<m2::PointD> const & polyline, size_t in
 }
 
 void FillProjections(std::vector<m2::PointD> & polyline, size_t startIndex, size_t endIndex,
-                     m2::PointD const & point, double distStopsM,
+                     m2::PointD const & point, double distStopsM, Direction direction,
                      std::vector<ProjectionData> & projections)
 {
+  CHECK_LESS_OR_EQUAL(startIndex, endIndex, ());
+
   double distTravelledM = 0.0;
   // Stop can't be further from its projection to line then |maxDistFromStopM|.
   double constexpr maxDistFromStopM = 1000;
 
-  for (size_t i = startIndex; i < endIndex; ++i)
-  {
-    if (i > startIndex)
-      distTravelledM += mercator::DistanceOnEarth(polyline[i - 1], polyline[i]);
+  size_t const from = direction == Direction::Forward ? startIndex : endIndex;
 
-    auto proj = GetProjection(polyline, i, ProjectStopOnTrack(point, polyline[i], polyline[i + 1]));
-    proj.m_distFromStart = distTravelledM + mercator::DistanceOnEarth(polyline[i], proj.m_proj);
+  auto const endCriterion = [&](size_t i) {
+    return direction == Direction::Forward ? i < endIndex : i > startIndex;
+  };
+
+  auto const move = [&](size_t & i) {
+    direction == Direction::Forward ? ++i : --i;
+    CHECK_GREATER_OR_EQUAL(i, 0, ());
+    CHECK_LESS_OR_EQUAL(i, polyline.size(), ());
+  };
+
+  for (size_t i = from; endCriterion(i); move(i))
+  {
+    auto const current = i;
+    auto const prev = direction == Direction::Forward ? i - 1 : i + 1;
+    auto const next = direction == Direction::Forward ? i + 1 : i - 1;
+
+    if (i != from)
+      distTravelledM += mercator::DistanceOnEarth(polyline[prev], polyline[current]);
+
+    auto proj = GetProjection(polyline, current, direction,
+                              ProjectStopOnTrack(point, polyline[current], polyline[next]));
+    proj.m_distFromEnding =
+        distTravelledM + mercator::DistanceOnEarth(polyline[current], proj.m_proj);
 
     // The distance on the polyline between the projections of stops must not be less than the
     // shortest possible distance between the stops themselves.
-    if (proj.m_distFromStart < distStopsM)
+    if (proj.m_distFromEnding < distStopsM)
       continue;
 
     if (proj.m_distFromPoint < maxDistFromStopM)
@@ -108,7 +134,7 @@ void FillProjections(std::vector<m2::PointD> & polyline, size_t startIndex, size
 
 std::pair<size_t, bool> PrepareNearestPointOnTrack(m2::PointD const & point,
                                                    std::optional<m2::PointD> const & prevPoint,
-                                                   size_t startIndex,
+                                                   size_t prevIndex, Direction direction,
                                                    std::vector<m2::PointD> & polyline)
 {
   // We skip 70% of the distance in a straight line between two stops for preventing incorrect
@@ -118,9 +144,12 @@ std::pair<size_t, bool> PrepareNearestPointOnTrack(m2::PointD const & point,
   std::vector<ProjectionData> projections;
   // Reserve space for points on polyline which are relatively close to the shape.
   // Approximately 1/4 of all points on shape.
-  projections.reserve((polyline.size() - startIndex) / 4);
+  auto const size = direction == Direction::Forward ? polyline.size() - prevIndex : prevIndex;
+  projections.reserve(size / 4);
 
-  FillProjections(polyline, startIndex, polyline.size() - 1, point, distStopsM, projections);
+  auto const startIndex = direction == Direction::Forward ? prevIndex : 0;
+  auto const endIndex = direction == Direction::Forward ? polyline.size() - 1 : prevIndex;
+  FillProjections(polyline, startIndex, endIndex, point, distStopsM, direction, projections);
 
   if (projections.empty())
     return {polyline.size() + 1, false};
@@ -128,24 +157,24 @@ std::pair<size_t, bool> PrepareNearestPointOnTrack(m2::PointD const & point,
   // We find the most fitting projection of the stop to the polyline. For two different projections
   // with approximately equal distances to the stop the most preferable is the one that is closer
   // to the beginning of the polyline segment.
-  auto proj =
-      std::min_element(projections.begin(), projections.end(),
-                       [](ProjectionData const & p1, ProjectionData const & p2) {
-                         if (CloserToStartAndOnSimilarDistToLine(p1, p2))
-                           return true;
+  auto const cmp = [](ProjectionData const & p1, ProjectionData const & p2) {
+    if (CloserToEndingAndOnSimilarDistToLine(p1, p2))
+      return true;
 
-                         if (CloserToStartAndOnSimilarDistToLine(p2, p1))
-                           return false;
+    if (CloserToEndingAndOnSimilarDistToLine(p2, p1))
+      return false;
 
-                         if (base::AlmostEqualAbs(p1.m_distFromPoint, p2.m_distFromPoint, kEps))
-                           return p1.m_distFromStart < p2.m_distFromStart;
+    if (p1.m_distFromPoint == p2.m_distFromPoint)
+      return p1.m_distFromEnding < p2.m_distFromEnding;
 
-                         return p1.m_distFromPoint < p2.m_distFromPoint;
-                       });
+    return p1.m_distFromPoint < p2.m_distFromPoint;
+  };
+
+  auto proj = std::min_element(projections.begin(), projections.end(), cmp);
 
   // This case is possible not only for the first stop on the shape. We try to resolve situation
   // when two stops are projected to the same point on the shape.
-  if (proj->m_indexOnShape == startIndex)
+  if (proj->m_indexOnShape == prevIndex)
   {
     proj = std::min_element(projections.begin(), projections.end(),
                          [](ProjectionData const & p1, ProjectionData const & p2) {
diff --git a/transit/world_feed/feed_helpers.hpp b/transit/world_feed/feed_helpers.hpp
index 339bad6610..ec1b5142da 100644
--- a/transit/world_feed/feed_helpers.hpp
+++ b/transit/world_feed/feed_helpers.hpp
@@ -20,6 +20,12 @@ struct ProjectionToShape
   double m_dist;
 };
 
+enum class Direction
+{
+  Forward,
+  Backward
+};
+
 /// \returns |stopPoint| projection to the track segment [|point1|, |point2|] and
 /// distance from the |stopPoint| to its projection.
 ProjectionToShape ProjectStopOnTrack(m2::PointD const & stopPoint, m2::PointD const & point1,
@@ -27,10 +33,11 @@ ProjectionToShape ProjectStopOnTrack(m2::PointD const & stopPoint, m2::PointD co
 
 /// \returns index of the nearest track point to the |point| and flag if it was inserted to the
 /// shape. If this index doesn't match already existent points, the stop projection is inserted to
-/// the |polyline| and the flag is set to true.
+/// the |polyline| and the flag is set to true. New point should follow prevPoint in the direction
+/// |direction|.
 std::pair<size_t, bool> PrepareNearestPointOnTrack(m2::PointD const & point,
                                                    std::optional<m2::PointD> const & prevPoint,
-                                                   size_t startIndex,
+                                                   size_t prevIndex, Direction direction,
                                                    std::vector<m2::PointD> & polyline);
 
 /// \returns true if we should not skip routes with this GTFS |routeType|.
diff --git a/transit/world_feed/world_feed.cpp b/transit/world_feed/world_feed.cpp
index 114e95da9d..9a1b956087 100644
--- a/transit/world_feed/world_feed.cpp
+++ b/transit/world_feed/world_feed.cpp
@@ -2,7 +2,6 @@
 
 #include "transit/transit_entities.hpp"
 #include "transit/world_feed/date_time_helpers.hpp"
-#include "transit/world_feed/feed_helpers.hpp"
 
 #include "platform/platform.hpp"
 
@@ -211,15 +210,9 @@ struct StopOnShape
   size_t m_index = 0;
 };
 
-enum class Direction
-{
-  Forward,
-  Backward
-};
-
 std::optional<size_t> GetStopIndex(
     std::unordered_map<transit::TransitId, std::vector<size_t>> const & stopIndexes,
-    transit::TransitId id, size_t fromIndex, Direction direction)
+    transit::TransitId id, size_t fromIndex, transit::Direction direction)
 {
   auto it = stopIndexes.find(id);
   CHECK(it != stopIndexes.end(), (id));
@@ -227,9 +220,11 @@ std::optional<size_t> GetStopIndex(
   std::optional<size_t> bestIdx;
   for (auto const & index : it->second)
   {
-    if (direction == Direction::Forward && index >= fromIndex && (!bestIdx || index < bestIdx))
+    if (direction == transit::Direction::Forward && index >= fromIndex &&
+        (!bestIdx || index < bestIdx))
       bestIdx = index;
-    if (direction == Direction::Backward && index <= fromIndex && (!bestIdx || index > bestIdx))
+    if (direction == transit::Direction::Backward && index <= fromIndex &&
+        (!bestIdx || index > bestIdx))
       bestIdx = index;
   }
   return bestIdx;
@@ -237,7 +232,8 @@ std::optional<size_t> GetStopIndex(
 
 std::optional<std::pair<StopOnShape, StopOnShape>> GetStopPairOnShape(
     std::unordered_map<transit::TransitId, std::vector<size_t>> const & stopIndexes,
-    transit::StopsOnLines const & stopsOnLines, size_t index, size_t fromIndex, Direction direction)
+    transit::StopsOnLines const & stopsOnLines, size_t index, size_t fromIndex,
+    transit::Direction direction)
 {
   auto const & stopIds = stopsOnLines.m_stopSeq;
 
@@ -276,35 +272,6 @@ Link::Link(transit::TransitId lineId, transit::TransitId shapeId, size_t shapeSi
   : m_lineId(lineId), m_shapeId(shapeId), m_shapeSize(shapeSize)
 {
 }
-
-Direction GetDirection(
-    transit::StopsOnLines const & stopsOnLines,
-    std::unordered_map<transit::TransitId, std::vector<size_t>> const & stopIndexes)
-{
-  auto const & stopIds = stopsOnLines.m_stopSeq;
-
-  if (stopIds.size() <= 1 || !stopsOnLines.m_isValid)
-    return Direction::Forward;
-
-  for (size_t i = 0; i < stopIds.size() - 1; ++i)
-  {
-    auto const id1 = stopIds[i];
-    auto const id2 = stopIds[i + 1];
-    auto const indexes1 = stopIndexes.find(id1);
-    auto const indexes2 = stopIndexes.find(id2);
-    CHECK(indexes1 != stopIndexes.end(), ());
-    CHECK(indexes2 != stopIndexes.end(), ());
-    if (indexes1->second.size() != 1 || indexes2->second.size() != 1)
-      continue;
-    auto const index1 = indexes1->second[0];
-    auto const index2 = indexes2->second[0];
-    if (index2 == index1)
-      continue;
-    return index2 > index1 ? Direction::Forward : Direction::Backward;
-  }
-
-  return Direction::Forward;
-}
 }  // namespace
 
 namespace transit
@@ -943,67 +910,79 @@ void WorldFeed::FillLinesSchedule()
   }
 }
 
-bool WorldFeed::ProjectStopsToShape(
+std::optional<Direction> WorldFeed::ProjectStopsToShape(
     ShapesIter & itShape, StopsOnLines const & stopsOnLines,
     std::unordered_map<TransitId, std::vector<size_t>> & stopsToIndexes)
 {
   IdList const & stopIds = stopsOnLines.m_stopSeq;
   TransitId const shapeId = itShape->first;
-  auto & shape = itShape->second.m_points;
-  std::optional<m2::PointD> prevPoint = std::nullopt;
 
-  for (size_t i = 0; i < stopIds.size(); ++i)
-  {
-    auto const & stopId = stopIds[i];
-    auto const itStop = m_stops.m_data.find(stopId);
-    CHECK(itStop != m_stops.m_data.end(), (stopId));
-    auto const & stop = itStop->second;
-
-    size_t const startIdx = i == 0 ? 0 : stopsToIndexes[stopIds[i - 1]].back();
-    auto const [curIdx, pointInserted] =
-        PrepareNearestPointOnTrack(stop.m_point, prevPoint, startIdx, shape);
-
-    if (curIdx > shape.size())
+  auto const tryProject = [&](Direction direction) {
+    auto shape = itShape->second.m_points;
+    std::optional<m2::PointD> prevPoint = std::nullopt;
+    for (size_t i = 0; i < stopIds.size(); ++i)
     {
-      CHECK(!itShape->second.m_lineIds.empty(), (shapeId));
-      TransitId const lineId = *stopsOnLines.m_lines.begin();
+      auto const & stopId = stopIds[i];
+      auto const itStop = m_stops.m_data.find(stopId);
+      CHECK(itStop != m_stops.m_data.end(), (stopId));
+      auto const & stop = itStop->second;
 
-      LOG(LWARNING,
-          ("Error projecting stops to the shape. GTFS trip id", m_lines.m_data[lineId].m_gtfsTripId,
-           "shapeId", shapeId, "stopId", stopId, "i", i, "start index on shape", startIdx,
-           "trips count", stopsOnLines.m_lines.size()));
-      return false;
-    }
+      size_t const prevIdx = i == 0 ? (direction == Direction::Forward ? 0 : shape.size())
+                                    : stopsToIndexes[stopIds[i - 1]].back();
+      auto const [curIdx, pointInserted] =
+          PrepareNearestPointOnTrack(stop.m_point, prevPoint, prevIdx, direction, shape);
 
-    prevPoint = std::optional<m2::PointD>(stop.m_point);
-
-    if (pointInserted)
-    {
-      for (auto & indexesList : stopsToIndexes)
+      if (curIdx > shape.size())
       {
-        for (auto & stopIndex : indexesList.second)
+        CHECK(!itShape->second.m_lineIds.empty(), (shapeId));
+        TransitId const lineId = *stopsOnLines.m_lines.begin();
+
+        LOG(LWARNING,
+            ("Error projecting stops to the shape. GTFS trip id",
+             m_lines.m_data[lineId].m_gtfsTripId, "shapeId", shapeId, "stopId", stopId, "i", i,
+             "previous index on shape", prevIdx, "trips count", stopsOnLines.m_lines.size()));
+        return false;
+      }
+
+      prevPoint = std::optional<m2::PointD>(stop.m_point);
+
+      if (pointInserted)
+      {
+        for (auto & indexesList : stopsToIndexes)
         {
-          if (stopIndex >= curIdx)
-            ++stopIndex;
+          for (auto & stopIndex : indexesList.second)
+          {
+            if (stopIndex >= curIdx)
+              ++stopIndex;
+          }
+        }
+
+        for (auto const & lineId : m_shapes.m_data[shapeId].m_lineIds)
+        {
+          auto & line = m_lines.m_data[lineId];
+
+          if (line.m_shapeLink.m_startIndex >= curIdx)
+            ++line.m_shapeLink.m_startIndex;
+
+          if (line.m_shapeLink.m_endIndex >= curIdx)
+            ++line.m_shapeLink.m_endIndex;
         }
       }
 
-      for (auto const & lineId : m_shapes.m_data[shapeId].m_lineIds)
-      {
-        auto & line = m_lines.m_data[lineId];
-
-        if (line.m_shapeLink.m_startIndex >= curIdx)
-          ++line.m_shapeLink.m_startIndex;
-
-        if (line.m_shapeLink.m_endIndex >= curIdx)
-          ++line.m_shapeLink.m_endIndex;
-      }
+      stopsToIndexes[stopId].push_back(curIdx);
     }
 
-    stopsToIndexes[stopId].push_back(curIdx);
-  }
+    itShape->second.m_points = shape;
+    return true;
+  };
 
-  return true;
+  if (tryProject(Direction::Forward))
+    return Direction::Forward;
+
+  if (tryProject(Direction::Backward))
+    return Direction::Backward;
+
+  return {};
 }
 
 std::unordered_map<TransitId, std::vector<StopsOnLines>> WorldFeed::GetStopsForShapeMatching()
@@ -1041,10 +1020,11 @@ std::unordered_map<TransitId, std::vector<StopsOnLines>> WorldFeed::GetStopsForS
   return stopsOnShapes;
 }
 
-size_t WorldFeed::ModifyShapes()
+std::pair<size_t, size_t> WorldFeed::ModifyShapes()
 {
   auto stopsOnShapes = GetStopsForShapeMatching();
   size_t invalidStopSequences = 0;
+  size_t validStopSequences = 0;
 
   for (auto & [shapeId, stopsLists] : stopsOnShapes)
   {
@@ -1065,14 +1045,19 @@ size_t WorldFeed::ModifyShapes()
         stopsOnLines.m_isValid = false;
         ++invalidStopSequences;
       }
-      else if (!ProjectStopsToShape(itShape, stopsOnLines, stopToShapeIndex))
+      else if (auto const direction = ProjectStopsToShape(itShape, stopsOnLines, stopToShapeIndex))
+      {
+        stopsOnLines.m_direction = *direction;
+        ++validStopSequences;
+      }
+      else
       {
         stopsOnLines.m_isValid = false;
         ++invalidStopSequences;
       }
 
       if (invalidStopSequences > kMaxInvalidShapesCount)
-        return invalidStopSequences;
+        return {invalidStopSequences, validStopSequences};
     }
 
     for (auto & stopsOnLines : stopsLists)
@@ -1080,52 +1065,59 @@ size_t WorldFeed::ModifyShapes()
       IdList const & stopIds = stopsOnLines.m_stopSeq;
       auto const & lineIds = stopsOnLines.m_lines;
       auto indexes = stopToShapeIndex;
-
-      auto const direction = GetDirection(stopsOnLines, indexes);
+      auto const direction = stopsOnLines.m_direction;
 
       size_t lastIndex = direction == Direction::Forward ? 0 : std::numeric_limits<size_t>::max();
       for (size_t i = 0; i < stopIds.size() - 1; ++i)
       {
         auto const stops = GetStopPairOnShape(indexes, stopsOnLines, i, lastIndex, direction);
-        if (!stops)
+        if (!stops && stopsOnLines.m_isValid)
         {
           stopsOnLines.m_isValid = false;
           ++invalidStopSequences;
+          --validStopSequences;
 
           if (invalidStopSequences > kMaxInvalidShapesCount)
-            return invalidStopSequences;
+            return {invalidStopSequences, validStopSequences};
         }
-        auto const [stop1, stop2] = *stops;
-        lastIndex = stop2.m_index;
 
         for (auto const lineId : lineIds)
         {
           if (!stopsOnLines.m_isValid)
-            m_lines.m_data.erase(lineId);
-
-          // Update |EdgeShapeLink| with shape segment start and end points.
-          auto itEdge = m_edges.m_data.find(EdgeId(stop1.m_id, stop2.m_id, lineId));
-          if (itEdge == m_edges.m_data.end())
-            continue;
-
-          if (stopsOnLines.m_isValid)
           {
-            itEdge->second.m_shapeLink.m_startIndex = static_cast<uint32_t>(stop1.m_index);
-            itEdge->second.m_shapeLink.m_endIndex = static_cast<uint32_t>(stop2.m_index);
+            m_lines.m_data.erase(lineId);
+            // todo: use std::erase_if after c++20
+            for (auto it = m_edges.m_data.begin(); it != m_edges.m_data.end();)
+            {
+              if (it->first.m_lineId == lineId)
+                it = m_edges.m_data.erase(it);
+              else
+                ++it;
+            }
           }
           else
           {
-            m_edges.m_data.erase(itEdge);
+            CHECK(stops, ());
+            auto const [stop1, stop2] = *stops;
+            lastIndex = stop2.m_index;
+
+            // Update |EdgeShapeLink| with shape segment start and end points.
+            auto itEdge = m_edges.m_data.find(EdgeId(stop1.m_id, stop2.m_id, lineId));
+            if (itEdge == m_edges.m_data.end())
+              continue;
+
+            itEdge->second.m_shapeLink.m_startIndex = static_cast<uint32_t>(stop1.m_index);
+            itEdge->second.m_shapeLink.m_endIndex = static_cast<uint32_t>(stop2.m_index);
+
+            if (indexes[stop1.m_id].size() > 1)
+              indexes[stop1.m_id].erase(indexes[stop1.m_id].begin());
           }
         }
-
-        if (indexes[stop1.m_id].size() > 1)
-          indexes[stop1.m_id].erase(indexes[stop1.m_id].begin());
       }
     }
   }
 
-  return invalidStopSequences;
+  return {invalidStopSequences, validStopSequences};
 }
 
 void WorldFeed::FillTransfers()
@@ -1467,10 +1459,10 @@ bool WorldFeed::SetFeed(gtfs::Feed && feed)
   }
   LOG(LINFO, ("Filled stop timetables and road graph edges."));
 
-  size_t const badShapesCount = ModifyShapes();
+  auto const [badShapesCount, goodShapesCount] = ModifyShapes();
   LOG(LINFO, ("Modified shapes."));
 
-  if (badShapesCount > kMaxInvalidShapesCount)
+  if (badShapesCount > kMaxInvalidShapesCount || (goodShapesCount == 0 && badShapesCount > 0))
   {
     LOG(LINFO, ("Corrupted shapes count exceeds allowable limit."));
     return false;
@@ -1931,6 +1923,9 @@ void WorldFeed::SplitLinesBasedData()
       auto const & stopIds = m_splitting.m_stops.at(region);
       auto const & [firstStopIdx, lastStopIdx] = GetStopsRange(lineData.m_stopIds, stopIds);
 
+      if (firstStopIdx == lastStopIdx)
+        continue;
+
       CHECK(StopIndexIsSet(firstStopIdx), ());
 
       lineInRegion.m_shapeLink.m_shapeId = lineData.m_shapeLink.m_shapeId;
diff --git a/transit/world_feed/world_feed.hpp b/transit/world_feed/world_feed.hpp
index d6c7087185..400e221bef 100644
--- a/transit/world_feed/world_feed.hpp
+++ b/transit/world_feed/world_feed.hpp
@@ -5,6 +5,7 @@
 #include "transit/transit_entities.hpp"
 #include "transit/transit_schedule.hpp"
 #include "transit/world_feed/color_picker.hpp"
+#include "transit/world_feed/feed_helpers.hpp"
 
 #include "geometry/mercator.hpp"
 #include "geometry/point2d.hpp"
@@ -244,6 +245,7 @@ struct StopsOnLines
   IdList m_stopSeq;
   IdSet m_lines;
   bool m_isValid = true;
+  transit::Direction m_direction = Direction::Forward;
 };
 
 using IdsInRegion = std::unordered_map<std::string, IdSet>;
@@ -328,8 +330,9 @@ private:
 
   std::unordered_map<TransitId, std::vector<StopsOnLines>> GetStopsForShapeMatching();
 
-  // Adds stops projections to shapes. Updates corresponding links to shapes.
-  size_t ModifyShapes();
+  // Adds stops projections to shapes. Updates corresponding links to shapes. Returns number of
+  // invalid and valid shapes.
+  std::pair<size_t, size_t> ModifyShapes();
   // Fills transfers based on GTFS transfers.
   void FillTransfers();
   // Fills gates based on GTFS stops.
@@ -337,8 +340,9 @@ private:
   // Recalculates 0-weights of edges based on the shape length.
   bool UpdateEdgeWeights();
 
-  bool ProjectStopsToShape(ShapesIter & itShape, StopsOnLines const & stopsOnLines,
-                           std::unordered_map<TransitId, std::vector<size_t>> & stopsToIndexes);
+  std::optional<Direction> ProjectStopsToShape(
+      ShapesIter & itShape, StopsOnLines const & stopsOnLines,
+      std::unordered_map<TransitId, std::vector<size_t>> & stopsToIndexes);
 
   // Splits data into regions.
   void SplitFeedIntoRegions();
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 dd2158c058..28bc703c4d 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
@@ -99,6 +99,23 @@ public:
     TEST(!m_globalFeed.SetFeed(std::move(feed)), ());
   }
 
+  void ReadFeedWithBackwardOrder()
+  {
+    gtfs::Feed feed(base::JoinPath(m_testPath, "feed_with_backward_order"));
+    TEST_EQUAL(feed.read_feed().code, gtfs::ResultCode::OK, ());
+    TEST(m_globalFeed.SetFeed(std::move(feed)), ());
+
+    TEST_EQUAL(m_globalFeed.m_networks.m_data.size(), 1, ());
+    TEST_EQUAL(m_globalFeed.m_routes.m_data.size(), 1, ());
+    TEST_EQUAL(m_globalFeed.m_lines.m_data.size(), 1, ());
+    TEST_EQUAL(m_globalFeed.m_stops.m_data.size(), 16, ());
+    TEST_EQUAL(m_globalFeed.m_shapes.m_data.size(), 1, ());
+    TEST_EQUAL(m_globalFeed.m_gates.m_data.size(), 0, ());
+    TEST_EQUAL(m_globalFeed.m_transfers.m_data.size(), 2, ());
+    TEST_EQUAL(m_globalFeed.m_edges.m_data.size(), 16, ());
+    TEST_EQUAL(m_globalFeed.m_edgesTransfers.m_data.size(), 2, ());
+  }
+
   // Test for train itinerary that passes through 4 regions in Europe and consists of 4 stops
   // (each in separate mwm) and 1 route with 1 line. This line passes through 4 stops:
   // [1] Switzerland_Ticino -> [2] Switzerland_Eastern ->
@@ -173,4 +190,9 @@ UNIT_CLASS_TEST(WorldFeedIntegrationTests, FeedWithWrongStopsOrder)
 {
   ReadFeedWithWrongStopsOrder();
 }
+
+UNIT_CLASS_TEST(WorldFeedIntegrationTests, FeedWithBackwardOrder)
+{
+  ReadFeedWithBackwardOrder();
+}
 }  // namespace transit
diff --git a/transit/world_feed/world_feed_tests/world_feed_tests.cpp b/transit/world_feed/world_feed_tests/world_feed_tests.cpp
index fc6812fdb1..a2a76d4ee6 100644
--- a/transit/world_feed/world_feed_tests/world_feed_tests.cpp
+++ b/transit/world_feed/world_feed_tests/world_feed_tests.cpp
@@ -211,7 +211,8 @@ UNIT_TEST(Transit_GTFS_ProjectStopToLine_Simple)
   // Test that point_A is projected between two existing polyline points and the new point is
   // added in the place of its projection.
   TestPlanFact(1 /* planIndex */, true /* planInsert */,
-               PrepareNearestPointOnTrack(point_A, std::nullopt, 0 /* startIndex */, shape));
+               PrepareNearestPointOnTrack(point_A, std::nullopt, 0 /* prevIndex */,
+                                          Direction::Forward, shape));
 
   TEST_EQUAL(shape.size(), 5, ());
   TEST_EQUAL(shape[1 /* expectedIndex */], m2::PointD(point_A.x, y), ());
@@ -220,17 +221,35 @@ UNIT_TEST(Transit_GTFS_ProjectStopToLine_Simple)
   // Expected point projection index is the same.
   // But this projection is not inserted (it is already present).
   TestPlanFact(1 /* planIndex */, false /* planInsert */,
-               PrepareNearestPointOnTrack(point_A, std::nullopt, 0 /* startIndex */, shape));
+               PrepareNearestPointOnTrack(point_A, std::nullopt, 0 /* prevIndex */,
+                                          Direction::Forward, shape));
   // So the shape size remains the same.
   TEST_EQUAL(shape.size(), 5, ());
 
   // Test that point_B insertion leads to addition of the new projection to the shape.
   TestPlanFact(4, true,
-               PrepareNearestPointOnTrack(point_B, std::nullopt, 1 /* startIndex */, shape));
+               PrepareNearestPointOnTrack(point_B, std::nullopt, 1 /* prevIndex */,
+                                          Direction::Forward, shape));
 
   // Test that point_C insertion does not lead to the addition of the new projection.
   TestPlanFact(5, false,
-               PrepareNearestPointOnTrack(point_C, std::nullopt, 4 /* startIndex */, shape));
+               PrepareNearestPointOnTrack(point_C, std::nullopt, 4 /* prevIndex */,
+                                          Direction::Forward, shape));
+
+  // Test point_C projection in backward direction.
+  TestPlanFact(5 /* planIndex */, false /* planInsert */,
+               PrepareNearestPointOnTrack(point_C, std::nullopt, shape.size() /* prevIndex */,
+                                          Direction::Backward, shape));
+
+  // Test point_B projection in backward direction.
+  TestPlanFact(4 /* planIndex */, false /* planInsert */,
+               PrepareNearestPointOnTrack(point_B, std::nullopt, 5 /* prevIndex */,
+                                          Direction::Backward, shape));
+
+  // Test point_A projection in backward direction.
+  TestPlanFact(1 /* planIndex */, false /* planInsert */,
+               PrepareNearestPointOnTrack(point_A, std::nullopt, 4 /* prevIndex */,
+                                          Direction::Backward, shape));
 }
 
 // Stop is on approximately the same distance from the segment (0, 1) and segment (1, 2).
@@ -251,7 +270,8 @@ UNIT_TEST(Transit_GTFS_ProjectStopToLine_DifferentStartIndexes)
   {
     auto shape = referenceShape;
     TestPlanFact(1, true,
-                 PrepareNearestPointOnTrack(point_A, std::nullopt, 0 /* startIndex */, shape));
+                 PrepareNearestPointOnTrack(point_A, std::nullopt, 0 /* prevIndex */,
+                                            Direction::Forward, shape));
     TEST_EQUAL(shape.size(), 4, ());
     TEST_EQUAL(shape[1 /* expectedIndex */], m2::PointD(0.001, point_A.y), ());
   }
@@ -260,7 +280,8 @@ UNIT_TEST(Transit_GTFS_ProjectStopToLine_DifferentStartIndexes)
   {
     auto shape = referenceShape;
     TestPlanFact(2, true,
-                 PrepareNearestPointOnTrack(point_A, std::nullopt, 1 /* startIndex */, shape));
+                 PrepareNearestPointOnTrack(point_A, std::nullopt, 1 /* prevIndex */,
+                                            Direction::Forward, shape));
     TEST_EQUAL(shape.size(), 4, ());
     TEST_EQUAL(shape[2 /* expectedIndex */], m2::PointD(point_A.x, 0.002), ());
   }
@@ -285,7 +306,8 @@ UNIT_TEST(Transit_GTFS_ProjectStopToLine_MaxDistance)
                                 {0.010, 0.0031}, {0.005, 0.0031}, {0.001, 0.0031}};
   m2::PointD const point_A{0.0028, 0.0029};
   TestPlanFact(1, true,
-               PrepareNearestPointOnTrack(point_A, std::nullopt, 0 /* startIndex */, shape));
+               PrepareNearestPointOnTrack(point_A, std::nullopt, 0 /* prevIndex */,
+                                          Direction::Forward, shape));
 }
 
 // Complex shape with multiple points on it and multiple stops for projection.
@@ -293,7 +315,7 @@ UNIT_TEST(Transit_GTFS_ProjectStopToLine_MaxDistance)
 //                   +-----+
 //              C*  /       \
 //          /+\    /         \  *D
-//       + /    \*/           \
+//       + /    \+/           \
 //      /                     +
 //     /                      |       *E
 //    +                       +-----+
@@ -309,7 +331,8 @@ UNIT_TEST(Transit_GTFS_ProjectStopToLine_MaxDistance)
 //
 UNIT_TEST(Transit_GTFS_ProjectStopToLine_NearCircle)
 {
-  std::vector<m2::PointD> shape{
+  double constexpr kEps = 1e-5;
+  std::vector<m2::PointD> const initialShape{
       {0.003, 0.001},   {0.003, 0.0015},  {0.0025, 0.002},  {0.002, 0.0025},  {0.001, 0.0025},
       {0.001, 0.0035},  {0.0015, 0.0045}, {0.0025, 0.005},  {0.0035, 0.0045}, {0.004, 0.0055},
       {0.0055, 0.0055}, {0.0065, 0.0045}, {0.0065, 0.0035}, {0.0075, 0.0035}, {0.0075, 0.0025},
@@ -321,18 +344,70 @@ UNIT_TEST(Transit_GTFS_ProjectStopToLine_NearCircle)
   m2::PointD const point_D{0.0063, 0.005};
   m2::PointD const point_E{0.008, 0.004};
   m2::PointD const point_F{0.0047, 0.0005};
+
+  // Forward
+  auto shape = initialShape;
   TestPlanFact(2, true,
-               PrepareNearestPointOnTrack(point_A, std::nullopt, 0 /* startIndex */, shape));
+               PrepareNearestPointOnTrack(point_A, std::nullopt, 0 /* prevIndex */,
+                                          Direction::Forward, shape));
+  auto const coordA = shape[2];
+
   TestPlanFact(3, false,
-               PrepareNearestPointOnTrack(point_B, std::nullopt, 2 /* startIndex */, shape));
+               PrepareNearestPointOnTrack(point_B, std::nullopt, 2 /* prevIndex */,
+                                          Direction::Forward, shape));
+  auto const coordB = shape[3];
+
   TestPlanFact(10, true,
-               PrepareNearestPointOnTrack(point_C, std::nullopt, 3 /* startIndex */, shape));
+               PrepareNearestPointOnTrack(point_C, std::nullopt, 3 /* prevIndex */,
+                                          Direction::Forward, shape));
+  auto const coordC = shape[10];
+
   TestPlanFact(12, false,
-               PrepareNearestPointOnTrack(point_D, std::nullopt, 10 /* startIndex */, shape));
+               PrepareNearestPointOnTrack(point_D, std::nullopt, 10 /* prevIndex */,
+                                          Direction::Forward, shape));
+  auto const coordD = shape[12];
+
   TestPlanFact(14, true,
-               PrepareNearestPointOnTrack(point_E, std::nullopt, 12 /* startIndex */, shape));
+               PrepareNearestPointOnTrack(point_E, std::nullopt, 12 /* prevIndex */,
+                                          Direction::Forward, shape));
+  auto const coordE = shape[14];
+
   TestPlanFact(20, true,
-               PrepareNearestPointOnTrack(point_F, std::nullopt, 14 /* startIndex */, shape));
+               PrepareNearestPointOnTrack(point_F, std::nullopt, 14 /* prevIndex */,
+                                          Direction::Forward, shape));
+
+  // Backward processing of reversed shape
+  shape = initialShape;
+  reverse(shape.begin(), shape.end());
+  TestPlanFact(17, true,
+               PrepareNearestPointOnTrack(point_A, std::nullopt, shape.size() /* prevIndex */,
+                                          Direction::Backward, shape));
+  TEST(base::AlmostEqualAbs(coordA, shape[17], kEps), (coordA, shape[17]));
+
+  TestPlanFact(16, false,
+               PrepareNearestPointOnTrack(point_B, std::nullopt, 17 /* prevIndex */,
+                                          Direction::Backward, shape));
+  TEST(base::AlmostEqualAbs(coordB, shape[16], kEps), (coordA, shape[17]));
+
+  TestPlanFact(10, true,
+               PrepareNearestPointOnTrack(point_C, std::nullopt, 16 /* prevIndex */,
+                                          Direction::Backward, shape));
+  TEST(base::AlmostEqualAbs(coordC, shape[10], kEps), (coordA, shape[17]));
+
+  TestPlanFact(8, false,
+               PrepareNearestPointOnTrack(point_D, std::nullopt, 10 /* prevIndex */,
+                                          Direction::Backward, shape));
+  TEST(base::AlmostEqualAbs(coordD, shape[8], kEps), (coordA, shape[17]));
+
+  TestPlanFact(7, true,
+               PrepareNearestPointOnTrack(point_E, std::nullopt, 8 /* prevIndex */,
+                                          Direction::Backward, shape));
+  TEST(base::AlmostEqualAbs(coordE, shape[7], kEps), (coordA, shape[17]));
+
+  // point_F has different position because we do not insert before point 0.
+  TestPlanFact(2, true,
+               PrepareNearestPointOnTrack(point_F, std::nullopt, 7 /* prevIndex */,
+                                          Direction::Backward, shape));
 }
 
 UNIT_TEST(Transit_ColorPicker)