diff --git a/base/small_map.hpp b/base/small_map.hpp
index 2b396a8f6e..919fd32ce1 100644
--- a/base/small_map.hpp
+++ b/base/small_map.hpp
@@ -33,6 +33,8 @@ public:
     return nullptr;
   }
 
+  size_t size() const { return m_map.size(); }
+
 protected:
   /// @todo buffer_vector is not suitable now, because Key/Value is not default constructible.
   std::vector<ValueType> m_map;
diff --git a/routing_common/bicycle_model.cpp b/routing_common/bicycle_model.cpp
index e626039167..bd00f54766 100644
--- a/routing_common/bicycle_model.cpp
+++ b/routing_common/bicycle_model.cpp
@@ -3,15 +3,10 @@
 #include "indexer/classificator.hpp"
 #include "indexer/feature.hpp"
 
-#include "base/assert.hpp"
-#include "base/macros.hpp"
-#include "base/logging.hpp"
-
-using namespace routing;
-using namespace std;
-
 namespace bicycle_model
 {
+using namespace routing;
+
 // See model specifics in different countries here:
 //   https://wiki.openstreetmap.org/wiki/OSM_tags_for_routing/Access-Restrictions
 // Document contains proposals for some countries, but we assume that some kinds of roads are ready for bicycle routing,
@@ -30,6 +25,10 @@ namespace bicycle_model
 
 HighwayBasedFactors const kDefaultFactors = GetOneFactorsForBicycleAndPedestrianModel();
 
+SpeedKMpH constexpr kSpeedOffroadKMpH = {1.5 /* weight */, 3.0 /* eta */};
+SpeedKMpH constexpr kSpeedDismountKMpH = {2.0 /* weight */, 2.0 /* eta */};
+SpeedKMpH constexpr kSpeedOnFootwayKMpH = {5.0 /* weight */, 7.0 /* eta */};
+
 HighwayBasedSpeeds const kDefaultSpeeds = {
     // {highway class : InOutCitySpeedKMpH(in city(weight, eta), out city(weight eta))}
     {HighwayType::HighwayTrunk, InOutCitySpeedKMpH(SpeedKMpH(3.0, 18.0))},
@@ -51,163 +50,84 @@ HighwayBasedSpeeds const kDefaultSpeeds = {
     {HighwayType::HighwayLivingStreet, InOutCitySpeedKMpH(SpeedKMpH(7.0, 8.0))},
     // Steps have obvious inconvenience of a bike in hands.
     {HighwayType::HighwaySteps, InOutCitySpeedKMpH(SpeedKMpH(1.0, 1.0))},
-    {HighwayType::HighwayPedestrian, InOutCitySpeedKMpH(SpeedKMpH(5.0))},
-    {HighwayType::HighwayFootway, InOutCitySpeedKMpH(SpeedKMpH(7.0, 5.0))},
-    {HighwayType::ManMadePier, InOutCitySpeedKMpH(SpeedKMpH(7.0))},
+    {HighwayType::HighwayPedestrian, InOutCitySpeedKMpH(kSpeedDismountKMpH)},
+    {HighwayType::HighwayFootway, InOutCitySpeedKMpH(kSpeedDismountKMpH)},
+    {HighwayType::ManMadePier, InOutCitySpeedKMpH(kSpeedOnFootwayKMpH)},
     {HighwayType::RouteFerry, InOutCitySpeedKMpH(SpeedKMpH(3.0, 20.0))},
 };
 
-SpeedKMpH constexpr kSpeedOffroadKMpH = {1.5 /* weight */, 3.0 /* eta */};
-
-// Default
-VehicleModel::LimitsInitList const kBicycleOptionsDefault = {
-    // {{roadType, roadType} passThroughAllowed}
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true}};
-
-// All options available.
-VehicleModel::LimitsInitList const kBicycleOptionsAll = {
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "bridleway"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true},
-    {{"highway", "footway"}, true}};
+// Default, no bridleway.
+VehicleModel::LimitsInitList const kDefaultOptions = {
+    // {HighwayType, passThroughAllowed}
+    {HighwayType::HighwayTrunk, true},
+    {HighwayType::HighwayTrunkLink, true},
+    {HighwayType::HighwayPrimary, true},
+    {HighwayType::HighwayPrimaryLink, true},
+    {HighwayType::HighwaySecondary, true},
+    {HighwayType::HighwaySecondaryLink, true},
+    {HighwayType::HighwayTertiary, true},
+    {HighwayType::HighwayTertiaryLink, true},
+    {HighwayType::HighwayService, true},
+    {HighwayType::HighwayUnclassified, true},
+    {HighwayType::HighwayRoad, true},
+    {HighwayType::HighwayTrack, true},
+    {HighwayType::HighwayPath, true},
+    // HighwayBridleway is missing
+    {HighwayType::HighwayCycleway, true},
+    {HighwayType::HighwayResidential, true},
+    {HighwayType::HighwayLivingStreet, true},
+    {HighwayType::HighwaySteps, true},
+    {HighwayType::HighwayPedestrian, true},
+    {HighwayType::HighwayFootway, true},
+    {HighwayType::ManMadePier, true},
+    {HighwayType::RouteFerry, true}
+};
 
 // Same as defaults except trunk and trunk_link are not allowed
-VehicleModel::LimitsInitList const kBicycleOptionsNoTrunk = {
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true}};
+VehicleModel::LimitsInitList NoTrunk()
+{
+  VehicleModel::LimitsInitList res;
+  res.reserve(kDefaultOptions.size() - 2);
+  for (auto const & e : kDefaultOptions)
+  {
+    if (e.m_type != HighwayType::HighwayTrunk && e.m_type != HighwayType::HighwayTrunkLink)
+      res.push_back(e);
+  }
+  return res;
+}
 
 // Same as defaults except pedestrian is allowed
-VehicleModel::LimitsInitList const kBicycleOptionsPedestrianAllowed = {
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true}};
+HighwayBasedSpeeds NormalPedestrianSpeed()
+{
+  HighwayBasedSpeeds res = kDefaultSpeeds;
+  res.Replace(HighwayType::HighwayPedestrian, InOutCitySpeedKMpH(kSpeedOnFootwayKMpH));
+  return res;
+}
 
 // Same as defaults except bridleway is allowed
-VehicleModel::LimitsInitList const kBicycleOptionsBridlewayAllowed = {
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "bridleway"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true}};
+VehicleModel::LimitsInitList AllAllowed()
+{
+  auto res = kDefaultOptions;
+  res.push_back({HighwayType::HighwayBridleway, true});
+  return res;
+}
 
 // Same as defaults except pedestrian and footway are allowed
-VehicleModel::LimitsInitList const kBicycleOptionsPedestrianFootwayAllowed = {
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true},
-    {{"highway", "footway"}, true}};
+HighwayBasedSpeeds NormalPedestrianAndFootwaySpeed()
+{
+  HighwayBasedSpeeds res = kDefaultSpeeds;
+  InOutCitySpeedKMpH const footSpeed(kSpeedOnFootwayKMpH);
+  res.Replace(HighwayType::HighwayPedestrian, footSpeed);
+  res.Replace(HighwayType::HighwayFootway, footSpeed);
+  return res;
+}
 
-// Australia
-VehicleModel::LimitsInitList const kBicycleOptionsAustralia = kBicycleOptionsAll;
-
-// Austria
-VehicleModel::LimitsInitList const kBicycleOptionsAustria = {
-    // No trunk, trunk_link, path
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true}};
-
-// Belarus
-VehicleModel::LimitsInitList const kBicycleOptionsBelarus = kBicycleOptionsPedestrianFootwayAllowed;
+HighwayBasedSpeeds DismountPathSpeed()
+{
+  HighwayBasedSpeeds res = kDefaultSpeeds;
+  res.Replace(HighwayType::HighwayPath, InOutCitySpeedKMpH(kSpeedDismountKMpH));
+  return res;
+}
 
 HighwayBasedSpeeds PreferFootwaysToRoads()
 {
@@ -228,169 +148,17 @@ HighwayBasedSpeeds PreferFootwaysToRoads()
   return res;
 }
 
-// Belgium
-VehicleModel::LimitsInitList const kBicycleOptionsBelgium = {
-    // No trunk, trunk_link
-    // Pedestrian is allowed
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true}};
-
-// Brazil
-VehicleModel::LimitsInitList const kBicycleOptionsBrazil = {
-    // Bridleway and fotway are allowed
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "bridleway"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "footway"}, true}};
-
-// Denmark
-VehicleModel::LimitsInitList const kBicycleOptionsDenmark = kBicycleOptionsNoTrunk;
-
-// France
-VehicleModel::LimitsInitList const kBicycleOptionsFrance = {
-    // No trunk, trunk_link
-    // Pedestrian is allowed
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true}};
-
-// Finland
-VehicleModel::LimitsInitList const kBicycleOptionsFinland = kBicycleOptionsPedestrianAllowed;
-
-// Germany
-VehicleModel::LimitsInitList const kBicycleOptionsGermany = kBicycleOptionsDefault;
-
-// Hungary
-VehicleModel::LimitsInitList const kBicycleOptionsHungary = kBicycleOptionsNoTrunk;
-
-// Iceland
-VehicleModel::LimitsInitList const kBicycleOptionsIceland = kBicycleOptionsAll;
-
-// Netherlands
-VehicleModel::LimitsInitList const kBicycleOptionsNetherlands = kBicycleOptionsNoTrunk;
-
-// Norway
-VehicleModel::LimitsInitList const kBicycleOptionsNorway = kBicycleOptionsAll;
-
-// Oman
-VehicleModel::LimitsInitList const kBicycleOptionsOman = kBicycleOptionsBridlewayAllowed;
-
-// Poland
-VehicleModel::LimitsInitList const kBicycleOptionsPoland = kBicycleOptionsNoTrunk;
-
-// Romania
-VehicleModel::LimitsInitList const kBicycleOptionsRomania = kBicycleOptionsNoTrunk;
-
-// Russian Federation
-// Footway and pedestrian are allowed
-// Note. Despite the fact that according to
-// https://wiki.openstreetmap.org/wiki/OSM_tags_for_routing/Access-Restrictions
-// passing through service and living_street with a bicycle is prohibited
-// it's allowed according to Russian traffic rules.
-VehicleModel::LimitsInitList const kBicycleOptionsRussia = kBicycleOptionsPedestrianFootwayAllowed;
-
-// Slovakia
-VehicleModel::LimitsInitList const kBicycleOptionsSlovakia = kBicycleOptionsNoTrunk;
-
-// Spain
-VehicleModel::LimitsInitList const kBicycleOptionsSpain = kBicycleOptionsPedestrianAllowed;
-
-// Switzerland
-VehicleModel::LimitsInitList const kBicycleOptionsSwitzerland = kBicycleOptionsNoTrunk;
-
-// Turkey
-VehicleModel::LimitsInitList const kBicycleOptionsTurkey = kBicycleOptionsDefault;
-
-// Ukraine
-VehicleModel::LimitsInitList const kBicycleOptionsUkraine = {
-    // No trunk
-    // Footway and pedestrian are allowed
-    // No pass through living_street and service
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, false},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, false},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true},
-    {{"highway", "footway"}, true}};
-
-// United Kingdom
-VehicleModel::LimitsInitList const kBicycleOptionsUK = kBicycleOptionsBridlewayAllowed;
-
-// United States of America
-VehicleModel::LimitsInitList const kBicycleOptionsUS = {
-    // Bridleway and pedesprian are allowed
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "bridleway"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true}};
+// No trunk, No pass through living_street and service
+VehicleModel::LimitsInitList UkraineOptions()
+{
+  auto res = NoTrunk();
+  for (auto & e : res)
+  {
+    if (e.m_type == HighwayType::HighwayLivingStreet || e.m_type == HighwayType::HighwayService)
+      e.m_isPassThroughAllowed = false;
+  }
+  return res;
+}
 
 VehicleModel::SurfaceInitList const kBicycleSurface = {
   // {{surfaceType, surfaceType}, {weightFactor, etaFactor}}
@@ -404,7 +172,7 @@ VehicleModel::SurfaceInitList const kBicycleSurface = {
 namespace routing
 {
 BicycleModel::BicycleModel()
-  : BicycleModel(bicycle_model::kBicycleOptionsDefault)
+  : BicycleModel(bicycle_model::kDefaultOptions)
 {
 }
 
@@ -416,41 +184,22 @@ BicycleModel::BicycleModel(VehicleModel::LimitsInitList const & limits)
 BicycleModel::BicycleModel(VehicleModel::LimitsInitList const & limits, HighwayBasedSpeeds const & speeds)
   : VehicleModel(classif(), limits, bicycle_model::kBicycleSurface, {speeds, bicycle_model::kDefaultFactors})
 {
+  // No bridleway in default.
+  ASSERT_EQUAL(bicycle_model::kDefaultOptions.size(), bicycle_model::kDefaultSpeeds.size() - 1, ());
+
   std::vector<std::string> hwtagYesBicycle = {"hwtag", "yesbicycle"};
 
   auto const & cl = classif();
-  m_noBicycleType = cl.GetTypeByPath({"hwtag", "nobicycle"});
-  m_yesBicycleType = cl.GetTypeByPath(hwtagYesBicycle);
+  m_noType = cl.GetTypeByPath({"hwtag", "nobicycle"});
+  m_yesType = cl.GetTypeByPath(hwtagYesBicycle);
   m_bidirBicycleType = cl.GetTypeByPath({"hwtag", "bidir_bicycle"});
   m_onedirBicycleType = cl.GetTypeByPath({"hwtag", "onedir_bicycle"});
 
   // Assign 90% of max cycleway speed for bicycle=yes to keep choosing most preferred cycleway.
   double const factor = 0.9;
   AddAdditionalRoadTypes(cl, {
-      {std::move(hwtagYesBicycle), {m_maxModelSpeed.m_inCity * factor, m_maxModelSpeed.m_outCity * factor}},
-      {{"route", "ferry"}, bicycle_model::kDefaultSpeeds.Get(HighwayType::RouteFerry)},
-      {{"man_made", "pier"}, bicycle_model::kDefaultSpeeds.Get(HighwayType::ManMadePier)}
+      {std::move(hwtagYesBicycle), {m_maxModelSpeed.m_inCity * factor, m_maxModelSpeed.m_outCity * factor}}
   });
-
-  // Small dismount speed with obvious inconvenience of a bike in hands.
-  InOutCitySpeedKMpH const dismountSpeed(DismountSpeed());
-
-  AddAdditionalRoadTypes(cl, {
-      {{"highway", "footway"}, dismountSpeed},
-      {{"highway", "pedestrian"}, dismountSpeed},
-      {{"highway", "steps"}, dismountSpeed}
-  });
-}
-
-VehicleModelInterface::RoadAvailability BicycleModel::GetRoadAvailability(feature::TypesHolder const & types) const
-{
-  if (types.Has(m_yesBicycleType))
-    return RoadAvailability::Available;
-
-  if (types.Has(m_noBicycleType))
-    return RoadAvailability::NotAvailable;
-
-  return RoadAvailability::Unknown;
 }
 
 bool BicycleModel::IsBicycleBidir(feature::TypesHolder const & types) const
@@ -488,14 +237,14 @@ SpeedKMpH const & BicycleModel::GetOffroadSpeed() const { return bicycle_model::
 // static
 BicycleModel const & BicycleModel::AllLimitsInstance()
 {
-  static BicycleModel const instance(bicycle_model::kBicycleOptionsAll);
+  static BicycleModel const instance(bicycle_model::AllAllowed(), bicycle_model::NormalPedestrianAndFootwaySpeed());
   return instance;
 }
 
 // static
 SpeedKMpH BicycleModel::DismountSpeed()
 {
-  return 2.0;
+  return bicycle_model::kSpeedDismountKMpH;
 }
 
 BicycleModelFactory::BicycleModelFactory(
@@ -503,34 +252,39 @@ BicycleModelFactory::BicycleModelFactory(
   : VehicleModelFactory(countryParentNameGetterFn)
 {
   using namespace bicycle_model;
+  using std::make_shared;
+
   // Names must be the same with country names from countries.txt
-  m_models[""] = make_shared<BicycleModel>(kBicycleOptionsDefault);
-  m_models["Australia"] = make_shared<BicycleModel>(kBicycleOptionsAustralia);
-  m_models["Austria"] = make_shared<BicycleModel>(kBicycleOptionsAustria);
+  m_models[""] = make_shared<BicycleModel>(kDefaultOptions);
 
+  m_models["Australia"] = make_shared<BicycleModel>(AllAllowed(), NormalPedestrianAndFootwaySpeed());
+  m_models["Austria"] = make_shared<BicycleModel>(NoTrunk(), DismountPathSpeed());
   // Belarus law demands to use footways for bicycles where possible.
-  m_models["Belarus"] = make_shared<BicycleModel>(kBicycleOptionsBelarus, PreferFootwaysToRoads());
-
-  m_models["Belgium"] = make_shared<BicycleModel>(kBicycleOptionsBelgium);
-  m_models["Brazil"] = make_shared<BicycleModel>(kBicycleOptionsBrazil);
-  m_models["Denmark"] = make_shared<BicycleModel>(kBicycleOptionsDenmark);
-  m_models["France"] = make_shared<BicycleModel>(kBicycleOptionsFrance);
-  m_models["Finland"] = make_shared<BicycleModel>(kBicycleOptionsFinland);
-  m_models["Germany"] = make_shared<BicycleModel>(kBicycleOptionsGermany);
-  m_models["Hungary"] = make_shared<BicycleModel>(kBicycleOptionsHungary);
-  m_models["Iceland"] = make_shared<BicycleModel>(kBicycleOptionsIceland);
-  m_models["Netherlands"] = make_shared<BicycleModel>(kBicycleOptionsNetherlands);
-  m_models["Norway"] = make_shared<BicycleModel>(kBicycleOptionsNorway);
-  m_models["Oman"] = make_shared<BicycleModel>(kBicycleOptionsOman);
-  m_models["Poland"] = make_shared<BicycleModel>(kBicycleOptionsPoland);
-  m_models["Romania"] = make_shared<BicycleModel>(kBicycleOptionsRomania);
-  m_models["Russian Federation"] = make_shared<BicycleModel>(kBicycleOptionsRussia);
-  m_models["Slovakia"] = make_shared<BicycleModel>(kBicycleOptionsSlovakia);
-  m_models["Spain"] = make_shared<BicycleModel>(kBicycleOptionsSpain);
-  m_models["Switzerland"] = make_shared<BicycleModel>(kBicycleOptionsSwitzerland);
-  m_models["Turkey"] = make_shared<BicycleModel>(kBicycleOptionsTurkey);
-  m_models["Ukraine"] = make_shared<BicycleModel>(kBicycleOptionsUkraine);
-  m_models["United Kingdom"] = make_shared<BicycleModel>(kBicycleOptionsUK);
-  m_models["United States of America"] = make_shared<BicycleModel>(kBicycleOptionsUS);
+  m_models["Belarus"] = make_shared<BicycleModel>(kDefaultOptions, PreferFootwaysToRoads());
+  m_models["Belgium"] = make_shared<BicycleModel>(NoTrunk(), NormalPedestrianSpeed());
+  m_models["Brazil"] = make_shared<BicycleModel>(AllAllowed());
+  m_models["Denmark"] = make_shared<BicycleModel>(NoTrunk());
+  m_models["France"] = make_shared<BicycleModel>(NoTrunk(), NormalPedestrianSpeed());
+  m_models["Finland"] = make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianSpeed());
+  m_models["Hungary"] = make_shared<BicycleModel>(NoTrunk());
+  m_models["Iceland"] = make_shared<BicycleModel>(AllAllowed(), NormalPedestrianAndFootwaySpeed());
+  m_models["Ireland"] = make_shared<BicycleModel>(AllAllowed());
+  m_models["Italy"] = make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianSpeed());
+  m_models["Netherlands"] = make_shared<BicycleModel>(NoTrunk());
+  m_models["Norway"] = make_shared<BicycleModel>(AllAllowed(), NormalPedestrianAndFootwaySpeed());
+  m_models["Oman"] = make_shared<BicycleModel>(AllAllowed());
+  m_models["Philippines"] = make_shared<BicycleModel>(AllAllowed(), NormalPedestrianSpeed());
+  m_models["Poland"] = make_shared<BicycleModel>(NoTrunk());
+  m_models["Romania"] = make_shared<BicycleModel>(AllAllowed());
+  // Note. Despite the fact that according to https://wiki.openstreetmap.org/wiki/OSM_tags_for_routing/Access-Restrictions
+  // passing through service and living_street with a bicycle is prohibited it's allowed according to Russian traffic rules.
+  m_models["Russian Federation"] = make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianAndFootwaySpeed());
+  m_models["Slovakia"] = make_shared<BicycleModel>(NoTrunk());
+  m_models["Spain"] = make_shared<BicycleModel>(NoTrunk(), NormalPedestrianSpeed());
+  m_models["Sweden"] = make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianSpeed());
+  m_models["Switzerland"] = make_shared<BicycleModel>(NoTrunk(), NormalPedestrianAndFootwaySpeed());
+  m_models["Ukraine"] = make_shared<BicycleModel>(UkraineOptions());
+  m_models["United Kingdom"] = make_shared<BicycleModel>(AllAllowed());
+  m_models["United States of America"] = make_shared<BicycleModel>(AllAllowed(), NormalPedestrianSpeed());
 }
 }  // routing
diff --git a/routing_common/bicycle_model.hpp b/routing_common/bicycle_model.hpp
index 1110f2029c..2020f89830 100644
--- a/routing_common/bicycle_model.hpp
+++ b/routing_common/bicycle_model.hpp
@@ -20,17 +20,12 @@ public:
   static BicycleModel const & AllLimitsInstance();
   static SpeedKMpH DismountSpeed();
 
-protected:
-  RoadAvailability GetRoadAvailability(feature::TypesHolder const & types) const override;
-
 private:
   /// @return true if it is allowed to ride a bicycle in both directions.
   bool IsBicycleBidir(feature::TypesHolder const & types) const;
   // Returns true if the road is explicitly set oneway for bicycles.
   bool IsBicycleOnedir(feature::TypesHolder const & types) const;
 
-  uint32_t m_noBicycleType = 0;
-  uint32_t m_yesBicycleType = 0;
   uint32_t m_bidirBicycleType = 0;
   uint32_t m_onedirBicycleType = 0;
 };
diff --git a/routing_common/car_model.cpp b/routing_common/car_model.cpp
index c8d95a2fd3..3503f4efc4 100644
--- a/routing_common/car_model.cpp
+++ b/routing_common/car_model.cpp
@@ -2,16 +2,9 @@
 #include "routing_common/car_model_coefs.hpp"
 
 #include "indexer/classificator.hpp"
-#include "indexer/feature.hpp"
-
-#include "base/macros.hpp"
-
-#include <array>
-#include <unordered_map>
 
 namespace car_model
 {
-using namespace std;
 using namespace routing;
 
 // See model specifics in different countries here:
@@ -28,105 +21,73 @@ using namespace routing;
 // of the route except for some edge cases.
 SpeedKMpH constexpr kSpeedOffroadKMpH = {0.01 /* weight */, kNotUsed /* eta */};
 
-VehicleModel::LimitsInitList const kCarOptionsDefault = {
-    // {{roadType, roadType}  passThroughAllowed}
-    {{"highway", "motorway"}, true},
-    {{"highway", "motorway_link"}, true},
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true}
+VehicleModel::LimitsInitList const kDefaultOptions = {
+    // {HighwayType, passThroughAllowed}
+    {HighwayType::HighwayMotorway, true},
+    {HighwayType::HighwayMotorwayLink, true},
+    {HighwayType::HighwayTrunk, true},
+    {HighwayType::HighwayTrunkLink, true},
+    {HighwayType::HighwayPrimary, true},
+    {HighwayType::HighwayPrimaryLink, true},
+    {HighwayType::HighwaySecondary, true},
+    {HighwayType::HighwaySecondaryLink, true},
+    {HighwayType::HighwayTertiary, true},
+    {HighwayType::HighwayTertiaryLink, true},
+    {HighwayType::HighwayResidential, true},
+    {HighwayType::HighwayUnclassified, true},
+    {HighwayType::HighwayService, true},
+    {HighwayType::HighwayLivingStreet, true},
+    {HighwayType::HighwayRoad, true},
+    {HighwayType::HighwayTrack, true},
+    {HighwayType::RailwayRailMotorVehicle, true},
+    {HighwayType::RouteShuttleTrain, true},
+    {HighwayType::RouteFerry, true},
+    {HighwayType::ManMadePier, true}
 };
 
-VehicleModel::LimitsInitList const kCarOptionsNoPassThroughLivingStreet = {
-    {{"highway", "motorway"}, true},
-    {{"highway", "motorway_link"}, true},
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "living_street"}, false},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true}};
+VehicleModel::LimitsInitList NoPassThroughLivingStreet()
+{
+  auto res = kDefaultOptions;
+  for (auto & e : res)
+  {
+    if (e.m_type == HighwayType::HighwayLivingStreet)
+      e.m_isPassThroughAllowed = false;
+  }
+  return res;
+}
 
-VehicleModel::LimitsInitList const kCarOptionsNoPassThroughLivingStreetAndService = {
-    {{"highway", "motorway"}, true},
-    {{"highway", "motorway_link"}, true},
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "service"}, false},
-    {{"highway", "living_street"}, false},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true}};
+VehicleModel::LimitsInitList NoPassThroughService(VehicleModel::LimitsInitList res = kDefaultOptions)
+{
+  for (auto & e : res)
+  {
+    if (e.m_type == HighwayType::HighwayService)
+      e.m_isPassThroughAllowed = false;
+  }
+  return res;
+}
 
-VehicleModel::LimitsInitList const kCarOptionsDenmark = {
-    // No track
-    {{"highway", "motorway"}, true},
-    {{"highway", "motorway_link"}, true},
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "road"}, true}};
+VehicleModel::LimitsInitList NoTrack()
+{
+  VehicleModel::LimitsInitList res;
+  res.reserve(kDefaultOptions.size() - 1);
+  for (auto const & e : kDefaultOptions)
+  {
+    if (e.m_type != HighwayType::HighwayTrack)
+      res.push_back(e);
+  }
+  return res;
+}
 
-VehicleModel::LimitsInitList const kCarOptionsGermany = {
-    // No pass through track
-    {{"highway", "motorway"}, true},
-    {{"highway", "motorway_link"}, true},
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, false}};
-
-VehicleModel::AdditionalRoadsList const kAdditionalRoads = {
-    // {{highway tags}, {weightSpeed, etaSpeed}}
-    {{"railway", "rail", "motor_vehicle"}, kHighwayBasedSpeeds.Get(HighwayType::RailwayRailMotorVehicle)},
-    {{"route", "shuttle_train"}, kHighwayBasedSpeeds.Get(HighwayType::RouteShuttleTrain)},
-    {{"route", "ferry"}, kHighwayBasedSpeeds.Get(HighwayType::RouteFerry)},
-    {{"man_made", "pier"}, kHighwayBasedSpeeds.Get(HighwayType::ManMadePier)}};
+VehicleModel::LimitsInitList NoPassThroughTrack()
+{
+  auto res = kDefaultOptions;
+  for (auto & e : res)
+  {
+    if (e.m_type == HighwayType::HighwayTrack)
+      e.m_isPassThroughAllowed = false;
+  }
+  return res;
+}
 
 /// @todo Should make some compare constrains (like in CarModel_TrackVsGravelTertiary test)
 /// to better fit these factors with reality. I have no idea, how they were set.
@@ -137,57 +98,26 @@ VehicleModel::SurfaceInitList const kCarSurface = {
   {{"psurface", "unpaved_good"}, {0.4, 0.8}},
   {{"psurface", "unpaved_bad"}, {0.2, 0.3}}
 };
-
-// Names must be the same with country names from countries.txt
-std::unordered_map<char const *, VehicleModel::LimitsInitList> const kCarOptionsByCountries = {
-    {"Austria", kCarOptionsNoPassThroughLivingStreet},
-    {"Belarus", kCarOptionsNoPassThroughLivingStreet},
-    {"Denmark", kCarOptionsDenmark},
-    {"Germany", kCarOptionsGermany},
-    {"Hungary", kCarOptionsNoPassThroughLivingStreet},
-    {"Romania", kCarOptionsNoPassThroughLivingStreet},
-    {"Russian Federation", kCarOptionsNoPassThroughLivingStreetAndService},
-    {"Slovakia", kCarOptionsNoPassThroughLivingStreet},
-    {"Ukraine", kCarOptionsNoPassThroughLivingStreetAndService}
-};
 }  // namespace car_model
 
 namespace routing
 {
-CarModel::CarModel()
-  : VehicleModel(classif(), car_model::kCarOptionsDefault, car_model::kCarSurface,
-                 {kHighwayBasedSpeeds, kHighwayBasedFactors})
+CarModel::CarModel() : CarModel(car_model::kDefaultOptions)
 {
-  Init();
 }
 
-CarModel::CarModel(VehicleModel::LimitsInitList const & roadLimits, HighwayBasedInfo const & info)
-  : VehicleModel(classif(), roadLimits, car_model::kCarSurface, info)
+CarModel::CarModel(VehicleModel::LimitsInitList const & roadLimits)
+  : VehicleModel(classif(), roadLimits, car_model::kCarSurface, {kHighwayBasedSpeeds, kHighwayBasedFactors})
 {
-  Init();
+  ASSERT_EQUAL(kHighwayBasedSpeeds.size(), kHighwayBasedFactors.size(), ());
+  ASSERT_EQUAL(kHighwayBasedSpeeds.size(), car_model::kDefaultOptions.size(), ());
+
+  m_noType = classif().GetTypeByPath({"hwtag", "nocar"});
+  m_yesType = classif().GetTypeByPath({"hwtag", "yescar"});
 }
 
 SpeedKMpH const & CarModel::GetOffroadSpeed() const { return car_model::kSpeedOffroadKMpH; }
 
-void CarModel::Init()
-{
-  m_noCarType = classif().GetTypeByPath({"hwtag", "nocar"});
-  m_yesCarType = classif().GetTypeByPath({"hwtag", "yescar"});
-
-  AddAdditionalRoadTypes(classif(), car_model::kAdditionalRoads);
-}
-
-VehicleModelInterface::RoadAvailability CarModel::GetRoadAvailability(feature::TypesHolder const & types) const
-{
-  if (types.Has(m_yesCarType))
-    return RoadAvailability::Available;
-
-  if (types.Has(m_noCarType))
-    return RoadAvailability::NotAvailable;
-
-  return RoadAvailability::Unknown;
-}
-
 // static
 CarModel const & CarModel::AllLimitsInstance()
 {
@@ -196,13 +126,7 @@ CarModel const & CarModel::AllLimitsInstance()
 }
 
 // static
-VehicleModel::LimitsInitList const & CarModel::GetOptions() { return car_model::kCarOptionsDefault; }
-
-// static
-VehicleModel::AdditionalRoadsList const & CarModel::GetAdditionalRoads()
-{
-  return car_model::kAdditionalRoads;
-}
+VehicleModel::LimitsInitList const & CarModel::GetOptions() { return car_model::kDefaultOptions; }
 
 // static
 VehicleModel::SurfaceInitList const & CarModel::GetSurfaces() { return car_model::kCarSurface; }
@@ -210,16 +134,22 @@ VehicleModel::SurfaceInitList const & CarModel::GetSurfaces() { return car_model
 CarModelFactory::CarModelFactory(CountryParentNameGetterFn const & countryParentNameGetterFn)
   : VehicleModelFactory(countryParentNameGetterFn)
 {
-  m_models[""] = std::make_shared<CarModel>(
-      car_model::kCarOptionsDefault,
-      HighwayBasedInfo(kHighwayBasedSpeeds, kHighwayBasedFactors));
+  using namespace car_model;
+  using std::make_shared;
 
-  for (auto const & kv : car_model::kCarOptionsByCountries)
-  {
-    auto const * country = kv.first;
-    auto const & limit = kv.second;
-    m_models[country] =
-        std::make_shared<CarModel>(limit, HighwayBasedInfo(kHighwayBasedSpeeds, kHighwayBasedFactors));
-  }
+  // Names must be the same with country names from countries.txt
+  m_models[""] = make_shared<CarModel>();
+
+  m_models["Austria"] = make_shared<CarModel>(NoPassThroughLivingStreet());
+  m_models["Belarus"] = make_shared<CarModel>(NoPassThroughLivingStreet());
+  m_models["Brazil"] = make_shared<CarModel>(NoPassThroughService(NoPassThroughTrack()));
+  m_models["Denmark"] = make_shared<CarModel>(NoTrack());
+  m_models["Germany"] = make_shared<CarModel>(NoPassThroughTrack());
+  m_models["Hungary"] = make_shared<CarModel>(NoPassThroughLivingStreet());
+  m_models["Poland"] = make_shared<CarModel>(NoPassThroughService());
+  m_models["Romania"] = make_shared<CarModel>(NoPassThroughLivingStreet());
+  m_models["Russian Federation"] = make_shared<CarModel>(NoPassThroughService(NoPassThroughLivingStreet()));
+  m_models["Slovakia"] = make_shared<CarModel>(NoPassThroughLivingStreet());
+  m_models["Ukraine"] = make_shared<CarModel>(NoPassThroughService(NoPassThroughLivingStreet()));
 }
 }  // namespace routing
diff --git a/routing_common/car_model.hpp b/routing_common/car_model.hpp
index 0f39874cde..8dab271a64 100644
--- a/routing_common/car_model.hpp
+++ b/routing_common/car_model.hpp
@@ -2,8 +2,6 @@
 
 #include "routing_common/vehicle_model.hpp"
 
-#include <vector>
-
 namespace routing
 {
 
@@ -11,24 +9,14 @@ class CarModel : public VehicleModel
 {
 public:
   CarModel();
-  CarModel(LimitsInitList const & roadLimits, HighwayBasedInfo const & info);
+  explicit CarModel(LimitsInitList const & roadLimits);
 
   // VehicleModelInterface overrides:
   SpeedKMpH const & GetOffroadSpeed() const override;
 
   static CarModel const & AllLimitsInstance();
   static LimitsInitList const & GetOptions();
-  static AdditionalRoadsList const & GetAdditionalRoads();
   static SurfaceInitList const & GetSurfaces();
-
-protected:
-  RoadAvailability GetRoadAvailability(feature::TypesHolder const & types) const override;
-
-private:
-  void Init();
-
-  uint32_t m_noCarType = 0;
-  uint32_t m_yesCarType = 0;
 };
 
 class CarModelFactory : public VehicleModelFactory
diff --git a/routing_common/car_model_coefs.hpp b/routing_common/car_model_coefs.hpp
index bb6468d18f..aabde94576 100644
--- a/routing_common/car_model_coefs.hpp
+++ b/routing_common/car_model_coefs.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "routing_common/maxspeed_conversion.hpp"
 #include "routing_common/vehicle_model.hpp"
 
 // These are default car model coefficients for open source developers.
diff --git a/routing_common/pedestrian_model.cpp b/routing_common/pedestrian_model.cpp
index 1bd4a4aa8e..b39915c370 100644
--- a/routing_common/pedestrian_model.cpp
+++ b/routing_common/pedestrian_model.cpp
@@ -3,15 +3,10 @@
 #include "indexer/classificator.hpp"
 #include "indexer/feature.hpp"
 
-#include "base/assert.hpp"
-#include "base/macros.hpp"
-#include "base/logging.hpp"
-
-using namespace routing;
-using namespace std;
-
 namespace pedestrian_model
 {
+using namespace routing;
+
 // See model specifics in different countries here:
 //   https://wiki.openstreetmap.org/wiki/OSM_tags_for_routing/Access-Restrictions
 // Document contains proposals for some countries, but we assume that some kinds of roads are ready for pedestrian routing,
@@ -61,204 +56,65 @@ HighwayBasedSpeeds const kDefaultSpeeds = {
 // 3 kmph (was before) is a big default offroad speed, almost as normal walking speed.
 SpeedKMpH constexpr kSpeedOffroadKMpH = {0.5 /* weight */, 3.0 /* eta */};
 
-// Default
-VehicleModel::LimitsInitList const kPedestrianOptionsDefault = {
-    // {{roadType, roadType} passThroughAllowed}
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true},
-    {{"highway", "footway"}, true}};
+// Default, no bridleway and cycleway
+VehicleModel::LimitsInitList const kDefaultOptions = {
+    // {HighwayType, passThroughAllowed}
+    {HighwayType::HighwayTrunk, true},
+    {HighwayType::HighwayTrunkLink, true},
+    {HighwayType::HighwayPrimary, true},
+    {HighwayType::HighwayPrimaryLink, true},
+    {HighwayType::HighwaySecondary, true},
+    {HighwayType::HighwaySecondaryLink, true},
+    {HighwayType::HighwayTertiary, true},
+    {HighwayType::HighwayTertiaryLink, true},
+    {HighwayType::HighwayService, true},
+    {HighwayType::HighwayUnclassified, true},
+    {HighwayType::HighwayRoad, true},
+    {HighwayType::HighwayTrack, true},
+    {HighwayType::HighwayPath, true},
+    // HighwayBridleway, HighwayCycleway are missing
+    {HighwayType::HighwayResidential, true},
+    {HighwayType::HighwayLivingStreet, true},
+    {HighwayType::HighwaySteps, true},
+    {HighwayType::HighwayPedestrian, true},
+    {HighwayType::HighwayFootway, true},
+    {HighwayType::ManMadePier, true},
+    {HighwayType::RouteFerry, true}
+};
 
-// All options available.
-VehicleModel::LimitsInitList const kPedestrianOptionsAll = {
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "bridleway"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true},
-    {{"highway", "footway"}, true}};
+// Same as defaults except bridleway and cycleway are allowed.
+VehicleModel::LimitsInitList AllAllowed()
+{
+  auto res = kDefaultOptions;
+  res.push_back({HighwayType::HighwayBridleway, true});
+  res.push_back({HighwayType::HighwayCycleway, true});
+  return res;
+}
 
 // Same as defaults except trunk and trunk link are not allowed.
-VehicleModel::LimitsInitList const kPedestrianOptionsNoTrunk = {
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true},
-    {{"highway", "footway"}, true}};
+VehicleModel::LimitsInitList NoTrunk()
+{
+  VehicleModel::LimitsInitList res;
+  res.reserve(kDefaultOptions.size() - 2);
+  for (auto const & e : kDefaultOptions)
+  {
+    if (e.m_type != HighwayType::HighwayTrunk && e.m_type != HighwayType::HighwayTrunkLink)
+      res.push_back(e);
+  }
+  return res;
+}
 
-// Same as defaults except cycleway is allowed.
-VehicleModel::LimitsInitList const kPedestrianOptionsCyclewayAllowed = {
-    {{"highway", "trunk"}, true},
-    {{"highway", "trunk_link"}, true},
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true},
-    {{"highway", "footway"}, true}};
+VehicleModel::LimitsInitList YesCycleway(VehicleModel::LimitsInitList res = kDefaultOptions)
+{
+  res.push_back({HighwayType::HighwayCycleway, true});
+  return res;
+}
 
-// Same as defaults except cycleway is allowed and trunk and trunk_link are not allowed.
-VehicleModel::LimitsInitList const kPedestrianOptionsCyclewayAllowedNoTrunk = {
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true},
-    {{"highway", "footway"}, true}};
-
-// Australia
-VehicleModel::LimitsInitList const kPedestrianOptionsAustralia = kPedestrianOptionsAll;
-
-// Austria
-VehicleModel::LimitsInitList const kPedestrianOptionsAustria = kPedestrianOptionsNoTrunk;
-
-// Belarus
-VehicleModel::LimitsInitList const kPedestrianOptionsBelarus = kPedestrianOptionsCyclewayAllowed;
-
-// Belgium
-VehicleModel::LimitsInitList const kPedestrianOptionsBelgium = {
-    // Trunk and trunk_link are not allowed
-    // Bridleway and cycleway are allowed
-    {{"highway", "primary"}, true},
-    {{"highway", "primary_link"}, true},
-    {{"highway", "secondary"}, true},
-    {{"highway", "secondary_link"}, true},
-    {{"highway", "tertiary"}, true},
-    {{"highway", "tertiary_link"}, true},
-    {{"highway", "service"}, true},
-    {{"highway", "unclassified"}, true},
-    {{"highway", "road"}, true},
-    {{"highway", "track"}, true},
-    {{"highway", "path"}, true},
-    {{"highway", "bridleway"}, true},
-    {{"highway", "cycleway"}, true},
-    {{"highway", "residential"}, true},
-    {{"highway", "living_street"}, true},
-    {{"highway", "steps"}, true},
-    {{"highway", "pedestrian"}, true},
-    {{"highway", "footway"}, true}};
-
-// Brazil
-VehicleModel::LimitsInitList const kPedestrianOptionsBrazil = kPedestrianOptionsAll;
-
-// Denmark
-VehicleModel::LimitsInitList const kPedestrianOptionsDenmark = kPedestrianOptionsCyclewayAllowedNoTrunk;
-
-// France
-VehicleModel::LimitsInitList const kPedestrianOptionsFrance = kPedestrianOptionsNoTrunk;
-
-// Finland
-VehicleModel::LimitsInitList const kPedestrianOptionsFinland = kPedestrianOptionsCyclewayAllowed;
-
-// Germany
-VehicleModel::LimitsInitList const kPedestrianOptionsGermany = kPedestrianOptionsDefault;
-
-// Hungary
-VehicleModel::LimitsInitList const kPedestrianOptionsHungary = kPedestrianOptionsNoTrunk;
-
-// Iceland
-VehicleModel::LimitsInitList const kPedestrianOptionsIceland = kPedestrianOptionsAll;
-
-// Netherlands
-VehicleModel::LimitsInitList const kPedestrianOptionsNetherlands = kPedestrianOptionsCyclewayAllowedNoTrunk;
-
-// Norway
-VehicleModel::LimitsInitList const kPedestrianOptionsNorway = kPedestrianOptionsAll;
-
-// Oman
-VehicleModel::LimitsInitList const kPedestrianOptionsOman = kPedestrianOptionsAll;
-
-// Poland
-VehicleModel::LimitsInitList const kPedestrianOptionsPoland = kPedestrianOptionsNoTrunk;
-
-// Romania
-VehicleModel::LimitsInitList const kPedestrianOptionsRomania = kPedestrianOptionsNoTrunk;
-
-// Russian Federation
-VehicleModel::LimitsInitList const kPedestrianOptionsRussia = kPedestrianOptionsCyclewayAllowed;
-
-// Slovakia
-VehicleModel::LimitsInitList const kPedestrianOptionsSlovakia = kPedestrianOptionsNoTrunk;
-
-// Spain
-VehicleModel::LimitsInitList const kPedestrianOptionsSpain = kPedestrianOptionsNoTrunk;
-
-// Switzerland
-VehicleModel::LimitsInitList const kPedestrianOptionsSwitzerland = kPedestrianOptionsNoTrunk;
-
-// Turkey
-VehicleModel::LimitsInitList const kPedestrianOptionsTurkey = kPedestrianOptionsAll;
-
-// Ukraine
-VehicleModel::LimitsInitList const kPedestrianOptionsUkraine = kPedestrianOptionsNoTrunk;
-
-// United Kingdom
-VehicleModel::LimitsInitList const kPedestrianOptionsUK = kPedestrianOptionsAll;
-
-// United States of America
-VehicleModel::LimitsInitList const kPedestrianOptionsUS = kPedestrianOptionsAll;
+VehicleModel::LimitsInitList YesBridleway(VehicleModel::LimitsInitList res = kDefaultOptions)
+{
+  res.push_back({HighwayType::HighwayBridleway, true});
+  return res;
+}
 
 VehicleModel::SurfaceInitList const kPedestrianSurface = {
   // {{surfaceType, surfaceType}, {weightFactor, etaFactor}}
@@ -271,7 +127,7 @@ VehicleModel::SurfaceInitList const kPedestrianSurface = {
 
 namespace routing
 {
-PedestrianModel::PedestrianModel() : PedestrianModel(pedestrian_model::kPedestrianOptionsDefault)
+PedestrianModel::PedestrianModel() : PedestrianModel(pedestrian_model::kDefaultOptions)
 {
 }
 
@@ -279,16 +135,15 @@ PedestrianModel::PedestrianModel(VehicleModel::LimitsInitList const & speedLimit
   : VehicleModel(classif(), speedLimits, pedestrian_model::kPedestrianSurface,
                 {pedestrian_model::kDefaultSpeeds, pedestrian_model::kDefaultFactors})
 {
+  // No bridleway and cycleway in default.
+  ASSERT_EQUAL(pedestrian_model::kDefaultOptions.size(), pedestrian_model::kDefaultSpeeds.size() - 2, ());
+
   std::vector<std::string> hwtagYesFoot = {"hwtag", "yesfoot"};
 
-  m_noFootType = classif().GetTypeByPath({ "hwtag", "nofoot" });
-  m_yesFootType = classif().GetTypeByPath(hwtagYesFoot);
+  m_noType = classif().GetTypeByPath({ "hwtag", "nofoot" });
+  m_yesType = classif().GetTypeByPath(hwtagYesFoot);
 
-  AddAdditionalRoadTypes(classif(), {
-      {std::move(hwtagYesFoot), m_maxModelSpeed},
-      {{"route", "ferry"}, pedestrian_model::kDefaultSpeeds.Get(HighwayType::RouteFerry)},
-      {{"man_made", "pier"}, pedestrian_model::kDefaultSpeeds.Get(HighwayType::ManMadePier)}
-  });
+  AddAdditionalRoadTypes(classif(), {{ std::move(hwtagYesFoot), m_maxModelSpeed }});
 }
 
 SpeedKMpH PedestrianModel::GetSpeed(FeatureType & f, SpeedParams const & speedParams) const
@@ -298,23 +153,12 @@ SpeedKMpH PedestrianModel::GetSpeed(FeatureType & f, SpeedParams const & speedPa
 
 SpeedKMpH const & PedestrianModel::GetOffroadSpeed() const { return pedestrian_model::kSpeedOffroadKMpH; }
 
-VehicleModelInterface::RoadAvailability PedestrianModel::GetRoadAvailability(feature::TypesHolder const & types) const
-{
-  if (types.Has(m_yesFootType))
-    return RoadAvailability::Available;
-
-  if (types.Has(m_noFootType))
-    return RoadAvailability::NotAvailable;
-
-  return RoadAvailability::Unknown;
-}
-
 // If one of feature types will be disabled for pedestrian, features of this type will be simplyfied
 // in generator. Look FeatureBuilder1::IsRoad() for more details.
 // static
 PedestrianModel const & PedestrianModel::AllLimitsInstance()
 {
-  static PedestrianModel const instance(pedestrian_model::kPedestrianOptionsAll);
+  static PedestrianModel const instance(pedestrian_model::AllAllowed());
   return instance;
 }
 
@@ -323,31 +167,37 @@ PedestrianModelFactory::PedestrianModelFactory(
   : VehicleModelFactory(countryParentNameGetterFn)
 {
   using namespace pedestrian_model;
+  using std::make_shared;
+
   // Names must be the same with country names from countries.txt
-  m_models[""] = make_shared<PedestrianModel>(kPedestrianOptionsDefault);
-  m_models["Australia"] = make_shared<PedestrianModel>(kPedestrianOptionsAustralia);
-  m_models["Austria"] = make_shared<PedestrianModel>(kPedestrianOptionsAustria);
-  m_models["Belarus"] = make_shared<PedestrianModel>(kPedestrianOptionsBelarus);
-  m_models["Belgium"] = make_shared<PedestrianModel>(kPedestrianOptionsBelgium);
-  m_models["Brazil"] = make_shared<PedestrianModel>(kPedestrianOptionsBrazil);
-  m_models["Denmark"] = make_shared<PedestrianModel>(kPedestrianOptionsDenmark);
-  m_models["France"] = make_shared<PedestrianModel>(kPedestrianOptionsFrance);
-  m_models["Finland"] = make_shared<PedestrianModel>(kPedestrianOptionsFinland);
-  m_models["Germany"] = make_shared<PedestrianModel>(kPedestrianOptionsGermany);
-  m_models["Hungary"] = make_shared<PedestrianModel>(kPedestrianOptionsHungary);
-  m_models["Iceland"] = make_shared<PedestrianModel>(kPedestrianOptionsIceland);
-  m_models["Netherlands"] = make_shared<PedestrianModel>(kPedestrianOptionsNetherlands);
-  m_models["Norway"] = make_shared<PedestrianModel>(kPedestrianOptionsNorway);
-  m_models["Oman"] = make_shared<PedestrianModel>(kPedestrianOptionsOman);
-  m_models["Poland"] = make_shared<PedestrianModel>(kPedestrianOptionsPoland);
-  m_models["Romania"] = make_shared<PedestrianModel>(kPedestrianOptionsRomania);
-  m_models["Russian Federation"] = make_shared<PedestrianModel>(kPedestrianOptionsRussia);
-  m_models["Slovakia"] = make_shared<PedestrianModel>(kPedestrianOptionsSlovakia);
-  m_models["Spain"] = make_shared<PedestrianModel>(kPedestrianOptionsSpain);
-  m_models["Switzerland"] = make_shared<PedestrianModel>(kPedestrianOptionsSwitzerland);
-  m_models["Turkey"] = make_shared<PedestrianModel>(kPedestrianOptionsTurkey);
-  m_models["Ukraine"] = make_shared<PedestrianModel>(kPedestrianOptionsUkraine);
-  m_models["United Kingdom"] = make_shared<PedestrianModel>(kPedestrianOptionsUK);
-  m_models["United States of America"] = make_shared<PedestrianModel>(kPedestrianOptionsUS);
+  m_models[""] = make_shared<PedestrianModel>(kDefaultOptions);
+
+  m_models["Australia"] = make_shared<PedestrianModel>(AllAllowed());
+  m_models["Austria"] = make_shared<PedestrianModel>(NoTrunk());
+  m_models["Belarus"] = make_shared<PedestrianModel>(YesCycleway());
+  m_models["Belgium"] = make_shared<PedestrianModel>(YesCycleway(YesBridleway(NoTrunk())));
+  m_models["Brazil"] = make_shared<PedestrianModel>(YesBridleway());
+  m_models["Denmark"] = make_shared<PedestrianModel>(YesCycleway(NoTrunk()));
+  m_models["France"] = make_shared<PedestrianModel>(NoTrunk());
+  m_models["Finland"] = make_shared<PedestrianModel>(YesCycleway());
+  m_models["Greece"] = make_shared<PedestrianModel>(YesCycleway(YesBridleway(NoTrunk())));
+  m_models["Hungary"] = make_shared<PedestrianModel>(NoTrunk());
+  m_models["Iceland"] = make_shared<PedestrianModel>(AllAllowed());
+  m_models["Ireland"] = make_shared<PedestrianModel>(AllAllowed());
+  m_models["Netherlands"] = make_shared<PedestrianModel>(YesCycleway(NoTrunk()));
+  m_models["Norway"] = make_shared<PedestrianModel>(AllAllowed());
+  m_models["Oman"] = make_shared<PedestrianModel>(AllAllowed());
+  m_models["Philippines"] = make_shared<PedestrianModel>(AllAllowed());
+  m_models["Poland"] = make_shared<PedestrianModel>(YesBridleway(NoTrunk()));
+  m_models["Romania"] = make_shared<PedestrianModel>(YesBridleway());
+  m_models["Russian Federation"] = make_shared<PedestrianModel>(YesCycleway());
+  m_models["Slovakia"] = make_shared<PedestrianModel>(NoTrunk());
+  m_models["Spain"] = make_shared<PedestrianModel>(NoTrunk());
+  m_models["Sweden"] = make_shared<PedestrianModel>(AllAllowed());
+  m_models["Switzerland"] = make_shared<PedestrianModel>(NoTrunk());
+  m_models["Turkey"] = make_shared<PedestrianModel>(AllAllowed());
+  m_models["Ukraine"] = make_shared<PedestrianModel>(NoTrunk());
+  m_models["United Kingdom"] = make_shared<PedestrianModel>(AllAllowed());
+  m_models["United States of America"] = make_shared<PedestrianModel>(AllAllowed());
 }
 }  // routing
diff --git a/routing_common/pedestrian_model.hpp b/routing_common/pedestrian_model.hpp
index 2423ce606f..a2faa26e4c 100644
--- a/routing_common/pedestrian_model.hpp
+++ b/routing_common/pedestrian_model.hpp
@@ -9,7 +9,7 @@ class PedestrianModel : public VehicleModel
 {
 public:
   PedestrianModel();
-  PedestrianModel(VehicleModel::LimitsInitList const & speedLimits);
+  explicit PedestrianModel(VehicleModel::LimitsInitList const & speedLimits);
 
   /// VehicleModelInterface overrides:
   SpeedKMpH GetSpeed(FeatureType & f, SpeedParams const & speedParams) const override;
@@ -17,15 +17,6 @@ public:
   SpeedKMpH const & GetOffroadSpeed() const override;
 
   static PedestrianModel const & AllLimitsInstance();
-
-protected:
-  RoadAvailability GetRoadAvailability(feature::TypesHolder const & types) const override;
-
-private:
-  void Init();
-
-  uint32_t m_noFootType = 0;
-  uint32_t m_yesFootType = 0;
 };
 
 class PedestrianModelFactory : public VehicleModelFactory
diff --git a/routing_common/routing_common_tests/vehicle_model_for_country_test.cpp b/routing_common/routing_common_tests/vehicle_model_for_country_test.cpp
index 9478a83463..d20b128356 100644
--- a/routing_common/routing_common_tests/vehicle_model_for_country_test.cpp
+++ b/routing_common/routing_common_tests/vehicle_model_for_country_test.cpp
@@ -4,7 +4,6 @@
 #include "routing_common/car_model.hpp"
 #include "routing_common/pedestrian_model.hpp"
 
-#include "indexer/classificator.hpp"
 #include "indexer/classificator_loader.hpp"
 
 #include <memory>
@@ -112,8 +111,8 @@ UNIT_CLASS_TEST(VehicleModelForCountryTest, CarModel_DirectParent)
 //    equals bicycle model for Russia and it's not default model.
 UNIT_CLASS_TEST(VehicleModelForCountryTest, BicycleModel_DirectParent)
 {
-  TestHaveNondefaultRestrictionForSelectedCountry<BicycleModel, BicycleModelFactory>(
-      "Russian Federation");
+  // Road types for RF are equal with defaults (speeds are not compared).
+//  TestHaveNondefaultRestrictionForSelectedCountry<BicycleModel, BicycleModelFactory>("Russian Federation");
   ParentTest<BicycleModel, BicycleModelFactory>("Moscow", "Russian Federation");
 }
 
diff --git a/routing_common/routing_common_tests/vehicle_model_test.cpp b/routing_common/routing_common_tests/vehicle_model_test.cpp
index f0feac3483..bd3c420bab 100644
--- a/routing_common/routing_common_tests/vehicle_model_test.cpp
+++ b/routing_common/routing_common_tests/vehicle_model_test.cpp
@@ -28,25 +28,30 @@ HighwayBasedSpeeds const kDefaultSpeeds = {
                         SpeedKMpH(50.0 /* weight */, 60.0 /* eta */) /* out city */)},
     {HighwayType::HighwayService,
      InOutCitySpeedKMpH(SpeedKMpH(47.0 /* weight */, 36.0 /* eta */) /* in city */,
-                        SpeedKMpH(50.0 /* weight */, 40.0 /* eta */) /* out city */)}};
+                        SpeedKMpH(50.0 /* weight */, 40.0 /* eta */) /* out city */)}
+};
 
 HighwayBasedFactors const kDefaultFactors = {
     {HighwayType::HighwayTrunk, InOutCityFactor(1.0)},
     {HighwayType::HighwayPrimary, InOutCityFactor(1.0)},
     {HighwayType::HighwaySecondary, InOutCityFactor(1.0)},
-    {HighwayType::HighwayResidential, InOutCityFactor(0.5)}};
+    {HighwayType::HighwayResidential, InOutCityFactor(0.5)}
+};
 
-VehicleModel::LimitsInitList const kTestLimits = {{{"highway", "trunk"}, true},
-                                                   {{"highway", "primary"}, true},
-                                                   {{"highway", "secondary"}, true},
-                                                   {{"highway", "residential"}, true},
-                                                   {{"highway", "service"}, false}};
+VehicleModel::LimitsInitList const kTestLimits = {
+  {HighwayType::HighwayTrunk, true},
+  {HighwayType::HighwayPrimary, true},
+  {HighwayType::HighwaySecondary, true},
+  {HighwayType::HighwayResidential, true},
+  {HighwayType::HighwayService, false}
+};
 
 VehicleModel::SurfaceInitList const kCarSurface = {
     {{"psurface", "paved_good"}, {0.8 /* weightFactor */, 0.9 /* etaFactor */}},
     {{"psurface", "paved_bad"}, {0.4, 0.5}},
     {{"psurface", "unpaved_good"}, {0.6, 0.8}},
-    {{"psurface", "unpaved_bad"}, {0.2, 0.2}}};
+    {{"psurface", "unpaved_bad"}, {0.2, 0.2}}
+};
 
 class VehicleModelTest
 {
diff --git a/routing_common/vehicle_model.cpp b/routing_common/vehicle_model.cpp
index d862893ab0..01226bf307 100644
--- a/routing_common/vehicle_model.cpp
+++ b/routing_common/vehicle_model.cpp
@@ -5,9 +5,6 @@
 #include "indexer/ftypes_matcher.hpp"
 
 #include "base/assert.hpp"
-#include "base/checked_cast.hpp"
-#include "base/macros.hpp"
-#include "base/math.hpp"
 
 #include <algorithm>
 #include <sstream>
@@ -54,14 +51,17 @@ VehicleModel::VehicleModel(Classificator const & classif, LimitsInitList const &
   m_roadTypes.Reserve(featureTypeLimits.size());
   for (auto const & v : featureTypeLimits)
   {
-    auto const clType = classif.GetTypeByPath(v.m_type);
-    auto const hwType = static_cast<HighwayType>(classif.GetIndexForType(clType));
-    auto const * speed = info.m_speeds.Find(hwType);
-    ASSERT(speed, ("Can't found speed for", hwType));
+    auto const * speed = info.m_speeds.Find(v.m_type);
+    ASSERT(speed, ("Can't found speed for", v.m_type));
 
-    /// @todo Consider using not only highway class speed but max_speed * max_speed_factor.
-    m_maxModelSpeed = Max(m_maxModelSpeed, *speed);
-    m_roadTypes.Insert(clType, v.m_isPassThroughAllowed);
+    if (v.m_type != HighwayType::RouteFerry && v.m_type != HighwayType::RailwayRailMotorVehicle &&
+        v.m_type != HighwayType::RouteShuttleTrain)
+    {
+      /// @todo Consider using not only highway class speed but max_speed * max_speed_factor.
+      m_maxModelSpeed = Max(m_maxModelSpeed, *speed);
+    }
+
+    m_roadTypes.Insert(classif.GetTypeForIndex(static_cast<uint32_t>(v.m_type)), v.m_isPassThroughAllowed);
   }
   m_roadTypes.FinishBuilding();
 
@@ -101,12 +101,7 @@ uint32_t VehicleModel::PrepareToMatchType(uint32_t type) const
 SpeedKMpH VehicleModel::GetSpeed(FeatureType & f, SpeedParams const & speedParams) const
 {
   feature::TypesHolder const types(f);
-
-  RoadAvailability const restriction = GetRoadAvailability(types);
-  if (restriction == RoadAvailability::NotAvailable || !HasRoadType(types))
-    return {};
-
-  return GetTypeSpeed(types, speedParams);
+  return IsRoadImpl(types) ? GetTypeSpeed(types, speedParams) : SpeedKMpH();
 }
 
 std::optional<HighwayType> VehicleModel::GetHighwayType(FeatureType & f) const
@@ -119,9 +114,6 @@ std::optional<HighwayType> VehicleModel::GetHighwayType(FeatureType & f) const
     auto const ret = GetHighwayType(t);
     if (ret)
       return *ret;
-
-    if (m_addRoadTypes.Find(t))
-      return static_cast<HighwayType>(classif().GetIndexForType(t));
   }
 
   // For example Denmark has "No track" profile (see kCarOptionsDenmark), but tracks exist in MWM.
@@ -249,14 +241,7 @@ bool VehicleModel::HasOneWayType(feature::TypesHolder const & types) const
 
 bool VehicleModel::IsRoad(FeatureType & f) const
 {
-  if (f.GetGeomType() != feature::GeomType::Line)
-    return false;
-
-  feature::TypesHolder const types(f);
-
-  if (GetRoadAvailability(types) == RoadAvailability::NotAvailable)
-    return false;
-  return HasRoadType(types);
+  return f.GetGeomType() == feature::GeomType::Line && IsRoadImpl(feature::TypesHolder(f));
 }
 
 bool VehicleModel::IsPassThroughAllowed(FeatureType & f) const
@@ -288,9 +273,18 @@ bool VehicleModel::IsRoadType(uint32_t type) const
   return m_addRoadTypes.Find(type) || m_roadTypes.Find(type);
 }
 
-VehicleModelInterface::RoadAvailability VehicleModel::GetRoadAvailability(feature::TypesHolder const &) const
+bool VehicleModel::IsRoadImpl(feature::TypesHolder const & types) const
 {
-  return RoadAvailability::Unknown;
+  for (uint32_t const t : types)
+  {
+    // Assume that Yes and No are not possible at the same time. Return first flag, otherwise.
+    if (t == m_yesType)
+      return true;
+    if (t == m_noType)
+      return false;
+  }
+
+  return HasRoadType(types);
 }
 
 VehicleModelFactory::VehicleModelFactory(
@@ -357,18 +351,6 @@ HighwayBasedFactors GetOneFactorsForBicycleAndPedestrianModel()
   };
 }
 
-string DebugPrint(VehicleModelInterface::RoadAvailability const l)
-{
-  switch (l)
-  {
-  case VehicleModelInterface::RoadAvailability::Available: return "Available";
-  case VehicleModelInterface::RoadAvailability::NotAvailable: return "NotAvailable";
-  case VehicleModelInterface::RoadAvailability::Unknown: return "Unknown";
-  }
-
-  UNREACHABLE();
-}
-
 string DebugPrint(SpeedKMpH const & speed)
 {
   ostringstream oss;
diff --git a/routing_common/vehicle_model.hpp b/routing_common/vehicle_model.hpp
index b4f1d96cda..483db72683 100644
--- a/routing_common/vehicle_model.hpp
+++ b/routing_common/vehicle_model.hpp
@@ -3,10 +3,8 @@
 #include "routing_common/maxspeed_conversion.hpp"
 
 #include "base/small_map.hpp"
-#include "base/stl_helpers.hpp"
 
 #include <array>
-#include <cstdint>
 #include <functional>
 #include <initializer_list>
 #include <limits>
@@ -15,7 +13,6 @@
 #include <sstream>
 #include <string>
 #include <unordered_map>
-#include <utility>
 #include <vector>
 
 class Classificator;
@@ -201,13 +198,6 @@ struct HighwayBasedInfo
 class VehicleModelInterface
 {
 public:
-  enum class RoadAvailability
-  {
-    NotAvailable,
-    Available,
-    Unknown,
-  };
-
   virtual ~VehicleModelInterface() = default;
 
   /// @return Allowed weight and ETA speed in KMpH.
@@ -258,7 +248,7 @@ class VehicleModel : public VehicleModelInterface
 public:
   struct FeatureTypeLimits
   {
-    std::vector<std::string> m_type;
+    HighwayType m_type;
     bool m_isPassThroughAllowed;      // pass through this road type is allowed
   };
 
@@ -275,7 +265,7 @@ public:
   };
 
   using AdditionalRoadsList = std::initializer_list<AdditionalRoad>;
-  using LimitsInitList = std::initializer_list<FeatureTypeLimits>;
+  using LimitsInitList = std::vector<FeatureTypeLimits>;
   using SurfaceInitList = std::initializer_list<FeatureTypeSurface>;
 
   VehicleModel(Classificator const & classif, LimitsInitList const & featureTypeLimits,
@@ -295,9 +285,7 @@ public:
 public:
   /// @returns true if |m_highwayTypes| or |m_addRoadTypes| contains |type| and false otherwise.
   bool IsRoadType(uint32_t type) const;
-
-  template <class TList>
-  bool HasRoadType(TList const & types) const
+  template <class TList> bool HasRoadType(TList const & types) const
   {
     for (uint32_t t : types)
     {
@@ -325,8 +313,8 @@ public:
   bool HasPassThroughType(feature::TypesHolder const & types) const;
 
 protected:
-  /// @returns a special restriction which is set to the feature.
-  virtual RoadAvailability GetRoadAvailability(feature::TypesHolder const & types) const;
+  uint32_t m_yesType, m_noType;
+  bool IsRoadImpl(feature::TypesHolder const & types) const;
 
   void AddAdditionalRoadTypes(Classificator const & classif, AdditionalRoadsList const & roads);
 
@@ -383,7 +371,6 @@ protected:
 
 HighwayBasedFactors GetOneFactorsForBicycleAndPedestrianModel();
 
-std::string DebugPrint(VehicleModelInterface::RoadAvailability const l);
 std::string DebugPrint(SpeedKMpH const & speed);
 std::string DebugPrint(SpeedFactor const & speedFactor);
 std::string DebugPrint(InOutCitySpeedKMpH const & speed);
diff --git a/track_analyzing/track_analyzer/cmd_table.cpp b/track_analyzing/track_analyzer/cmd_table.cpp
index 03a9ec4a02..465fd2507b 100644
--- a/track_analyzing/track_analyzer/cmd_table.cpp
+++ b/track_analyzing/track_analyzer/cmd_table.cpp
@@ -93,11 +93,8 @@ public:
   {
     auto const & cl = classif();
 
-    for (auto const & road : CarModel::GetAdditionalRoads())
-      m_hwtags.push_back(cl.GetTypeByPath(road.m_type));
-
     for (auto const & speed : CarModel::GetOptions())
-      m_hwtags.push_back(cl.GetTypeByPath(speed.m_type));
+      m_hwtags.push_back(cl.GetTypeForIndex(static_cast<uint32_t>(speed.m_type)));
 
     for (auto const & surface : CarModel::GetSurfaces())
       m_surfaceTags.push_back(cl.GetTypeByPath(surface.m_type));