diff --git a/routing_common/bicycle_model.cpp b/routing_common/bicycle_model.cpp
index 2fc47d910d..8ab96c3c5a 100644
--- a/routing_common/bicycle_model.cpp
+++ b/routing_common/bicycle_model.cpp
@@ -73,32 +73,6 @@ routing::VehicleModel::InitListT const g_bicycleLimitsDefault =
 
 // All options available.
 routing::VehicleModel::InitListT const g_bicycleLimitsAll =
-{
-  { {"highway", "trunk"},          kSpeedCyclewayKMpH,      true },
-  { {"highway", "trunk_link"},     kSpeedCyclewayKMpH,      true },
-  { {"highway", "primary"},        kSpeedCyclewayKMpH,      true },
-  { {"highway", "primary_link"},   kSpeedCyclewayKMpH,      true },
-  { {"highway", "secondary"},      kSpeedCyclewayKMpH,      true },
-  { {"highway", "secondary_link"}, kSpeedCyclewayKMpH,      true },
-  { {"highway", "tertiary"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedCyclewayKMpH,      true },
-  { {"highway", "service"},        kSpeedCyclewayKMpH,      true },
-  { {"highway", "unclassified"},   kSpeedCyclewayKMpH,      true },
-  { {"highway", "road"},           kSpeedCyclewayKMpH,      true },
-  { {"highway", "track"},          kSpeedCyclewayKMpH,      true },
-  { {"highway", "path"},           kSpeedCyclewayKMpH,      true },
-  { {"highway", "bridleway"},      kSpeedCyclewayKMpH,      true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedCyclewayKMpH,      true },
-  { {"highway", "living_street"},  kSpeedCyclewayKMpH,      true },
-  { {"highway", "steps"},          kSpeedCyclewayKMpH,      true },
-  { {"highway", "pedestrian"},     kSpeedCyclewayKMpH,      true },
-  { {"highway", "footway"},        kSpeedCyclewayKMpH,      true },
-  { {"highway", "platform"},       kSpeedCyclewayKMpH,      true },
-};
-
-// Australia
-routing::VehicleModel::InitListT const g_bicycleLimitsAustralia =
 {
   { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
   { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
@@ -123,9 +97,82 @@ routing::VehicleModel::InitListT const g_bicycleLimitsAustralia =
   { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
 };
 
+// Same as defaults except trunk and trunk_link are not allowed
+routing::VehicleModel::InitListT const g_bicycleLimitsNoTrunk =
+{
+  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
+  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
+  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
+  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
+  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
+  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
+  { {"highway", "service"},        kSpeedServiceKMpH,       true },
+  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
+  { {"highway", "road"},           kSpeedRoadKMpH,          true },
+  { {"highway", "track"},          kSpeedTrackKMpH,         true },
+  { {"highway", "path"},           kSpeedPathKMpH,          true },
+  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
+  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
+  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
+  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
+  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
+};
+
+// Same as defaults except pedestrian is allowed
+routing::VehicleModel::InitListT const g_bicycleLimitsPedestrianAllowed =
+{
+  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
+  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
+  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
+  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
+  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
+  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
+  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
+  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
+  { {"highway", "service"},        kSpeedServiceKMpH,       true },
+  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
+  { {"highway", "road"},           kSpeedRoadKMpH,          true },
+  { {"highway", "track"},          kSpeedTrackKMpH,         true },
+  { {"highway", "path"},           kSpeedPathKMpH,          true },
+  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
+  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
+  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
+  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
+  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
+  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
+};
+
+// Same as defaults except bridleway is allowed
+routing::VehicleModel::InitListT const g_bicycleLimitsBridlewayAllowed =
+{
+  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
+  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
+  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
+  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
+  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
+  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
+  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
+  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
+  { {"highway", "service"},        kSpeedServiceKMpH,       true },
+  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
+  { {"highway", "road"},           kSpeedRoadKMpH,          true },
+  { {"highway", "track"},          kSpeedTrackKMpH,         true },
+  { {"highway", "path"},           kSpeedPathKMpH,          true },
+  { {"highway", "bridleway"},      kSpeedBridlewayKMpH,     true },
+  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
+  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
+  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
+  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
+  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
+};
+
+// Australia
+routing::VehicleModel::InitListT const g_bicycleLimitsAustralia = g_bicycleLimitsAll;
+
 // Austria
 routing::VehicleModel::InitListT const g_bicycleLimitsAustria =
 {
+  // No trunk, trunk_link, path
   { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
   { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
   { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
@@ -146,6 +193,7 @@ routing::VehicleModel::InitListT const g_bicycleLimitsAustria =
 // Belarus
 routing::VehicleModel::InitListT const g_bicycleLimitsBelarus =
 {
+  // Footway and pedestrian are allowed
   { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
   { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
   { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
@@ -171,6 +219,8 @@ routing::VehicleModel::InitListT const g_bicycleLimitsBelarus =
 // Belgium
 routing::VehicleModel::InitListT const g_bicycleLimitsBelgium =
 {
+  // No trunk, trunk_link
+  // Pedestrian is allowed
   { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
   { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
   { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
@@ -193,6 +243,7 @@ routing::VehicleModel::InitListT const g_bicycleLimitsBelgium =
 // Brazil
 routing::VehicleModel::InitListT const g_bicycleLimitsBrazil =
 {
+  // Bridleway and fotway are allowed
   { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
   { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
   { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
@@ -211,35 +262,18 @@ routing::VehicleModel::InitListT const g_bicycleLimitsBrazil =
   { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
   { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
   { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
   { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
   { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
 };
 
 // Denmark
-routing::VehicleModel::InitListT const g_bicycleLimitsDenmark =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsDenmark = g_bicycleLimitsNoTrunk;
 
 // France
 routing::VehicleModel::InitListT const g_bicycleLimitsFrance =
 {
+  // No trunk, trunk_link
+  // Pedestrian is allowed
   { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
   { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
   { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
@@ -260,165 +294,37 @@ routing::VehicleModel::InitListT const g_bicycleLimitsFrance =
 };
 
 // Finland
-routing::VehicleModel::InitListT const g_bicycleLimitsFinland =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsFinland = g_bicycleLimitsPedestrianAllowed;
 
 // Germany
-routing::VehicleModel::InitListT const g_bicycleLimitsGermany =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsGermany = g_bicycleLimitsDefault;
 
 // Hungary
-routing::VehicleModel::InitListT const g_bicycleLimitsHungary =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsHungary = g_bicycleLimitsNoTrunk;
+
+// Iceland
+routing::VehicleModel::InitListT const g_bicycleLimitsIceland = g_bicycleLimitsAll;
 
 // Netherlands
-routing::VehicleModel::InitListT const g_bicycleLimitsNetherlands =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsNetherlands = g_bicycleLimitsNoTrunk;
 
 // Norway
-routing::VehicleModel::InitListT const g_bicycleLimitsNorway =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "bridleway"},      kSpeedBridlewayKMpH,     true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsNorway = g_bicycleLimitsAll;
+
+// Oman
+routing::VehicleModel::InitListT const g_bicycleLimitsOman = g_bicycleLimitsBridlewayAllowed;
 
 // Poland
-routing::VehicleModel::InitListT const g_bicycleLimitsPoland =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsPoland = g_bicycleLimitsNoTrunk;
 
 // Romania
-routing::VehicleModel::InitListT const g_bicycleLimitsRomania =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsRomania = g_bicycleLimitsNoTrunk;
 
-// Russia
+// Russian Federation
 routing::VehicleModel::InitListT const g_bicycleLimitsRussia =
 {
+  // Footway and pedestrian are allowed
+  // No transit for service and living_street
   { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
   { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
   { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
@@ -442,75 +348,23 @@ routing::VehicleModel::InitListT const g_bicycleLimitsRussia =
 };
 
 // Slovakia
-routing::VehicleModel::InitListT const g_bicycleLimitsSlovakia =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsSlovakia = g_bicycleLimitsNoTrunk;
+
+// Spain
+routing::VehicleModel::InitListT const g_bicycleLimitsSpain = g_bicycleLimitsPedestrianAllowed;
 
 // Switzerland
-routing::VehicleModel::InitListT const g_bicycleLimitsSwitzerland =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsSwitzerland = g_bicycleLimitsNoTrunk;
 
 // Turkey
-routing::VehicleModel::InitListT const g_bicycleLimitsTurkey =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsTurkey = g_bicycleLimitsDefault;
 
 // Ukraine
 routing::VehicleModel::InitListT const g_bicycleLimitsUkraine =
 {
+  // No trunk
+  // Footway and perestrian are allowed
+  // No transit for living_street and service
   { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
   { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
   { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
@@ -532,32 +386,12 @@ routing::VehicleModel::InitListT const g_bicycleLimitsUkraine =
 };
 
 // United Kingdom
-routing::VehicleModel::InitListT const g_bicycleLimitsUK =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "bridleway"},      kSpeedBridlewayKMpH,     true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_bicycleLimitsUK = g_bicycleLimitsBridlewayAllowed;
 
-// USA
-routing::VehicleModel::InitListT const g_bicycleLimitsUSA =
+// United States of America
+routing::VehicleModel::InitListT const g_bicycleLimitsUS =
 {
+  // Bridleway and pedesprian are allowed
   { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
   { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
   { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
@@ -649,6 +483,7 @@ BicycleModel const & BicycleModel::AllLimitsInstance()
 
 BicycleModelFactory::BicycleModelFactory()
 {
+  // Names must be the same with country names from countries.txt
   m_models[string()] = make_shared<BicycleModel>(g_bicycleLimitsDefault);
   m_models["Australia"] = make_shared<BicycleModel>(g_bicycleLimitsAustralia);
   m_models["Austria"] = make_shared<BicycleModel>(g_bicycleLimitsAustria);
@@ -660,17 +495,20 @@ BicycleModelFactory::BicycleModelFactory()
   m_models["Finland"] = make_shared<BicycleModel>(g_bicycleLimitsFinland);
   m_models["Germany"] = make_shared<BicycleModel>(g_bicycleLimitsGermany);
   m_models["Hungary"] = make_shared<BicycleModel>(g_bicycleLimitsHungary);
+  m_models["Iceland"] = make_shared<BicycleModel>(g_bicycleLimitsIceland);
   m_models["Netherlands"] = make_shared<BicycleModel>(g_bicycleLimitsNetherlands);
   m_models["Norway"] = make_shared<BicycleModel>(g_bicycleLimitsNorway);
+  m_models["Oman"] = make_shared<BicycleModel>(g_bicycleLimitsOman);
   m_models["Poland"] = make_shared<BicycleModel>(g_bicycleLimitsPoland);
   m_models["Romania"] = make_shared<BicycleModel>(g_bicycleLimitsRomania);
-  m_models["Russia"] = make_shared<BicycleModel>(g_bicycleLimitsRussia);
+  m_models["Russian Federation"] = make_shared<BicycleModel>(g_bicycleLimitsRussia);
   m_models["Slovakia"] = make_shared<BicycleModel>(g_bicycleLimitsSlovakia);
+  m_models["Spain"] = make_shared<BicycleModel>(g_bicycleLimitsSpain);
   m_models["Switzerland"] = make_shared<BicycleModel>(g_bicycleLimitsSwitzerland);
   m_models["Turkey"] = make_shared<BicycleModel>(g_bicycleLimitsTurkey);
   m_models["Ukraine"] = make_shared<BicycleModel>(g_bicycleLimitsUkraine);
-  m_models["UK"] = make_shared<BicycleModel>(g_bicycleLimitsUK);
-  m_models["USA"] = make_shared<BicycleModel>(g_bicycleLimitsUSA);
+  m_models["United Kingdom"] = make_shared<BicycleModel>(g_bicycleLimitsUK);
+  m_models["United States of America"] = make_shared<BicycleModel>(g_bicycleLimitsUS);
 }
 
 shared_ptr<IVehicleModel> BicycleModelFactory::GetVehicleModel() const
diff --git a/routing_common/bicycle_model.hpp b/routing_common/bicycle_model.hpp
index 8c26d0a2a0..d6f4a2b542 100644
--- a/routing_common/bicycle_model.hpp
+++ b/routing_common/bicycle_model.hpp
@@ -2,9 +2,9 @@
 
 #include "routing_common/vehicle_model.hpp"
 
-#include "std/shared_ptr.hpp"
-#include "std/string.hpp"
-#include "std/unordered_map.hpp"
+#include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace routing
 {
@@ -41,11 +41,11 @@ public:
 
   /// @name Overrides from VehicleModelFactory.
   //@{
-  shared_ptr<IVehicleModel> GetVehicleModel() const override;
-  shared_ptr<IVehicleModel> GetVehicleModelForCountry(string const & country) const override;
+  std::shared_ptr<IVehicleModel> GetVehicleModel() const override;
+  std::shared_ptr<IVehicleModel> GetVehicleModelForCountry(std::string const & country) const override;
   //@}
 
 private:
-  unordered_map<string, shared_ptr<IVehicleModel>> m_models;
+  std::unordered_map<std::string, std::shared_ptr<IVehicleModel>> m_models;
 };
 }  // namespace routing
diff --git a/routing_common/car_model.cpp b/routing_common/car_model.cpp
index b1c9613537..35a1d5be6e 100644
--- a/routing_common/car_model.cpp
+++ b/routing_common/car_model.cpp
@@ -4,10 +4,18 @@
 
 #include "indexer/classificator.hpp"
 
-#include "std/vector.hpp"
+#include <vector>
+
+using namespace std;
 
 namespace
 {
+// See model specifics in different countries here:
+//   http://wiki.openstreetmap.org/wiki/OSM_tags_for_routing/Access-Restrictions
+
+// See road types here:
+//   http://wiki.openstreetmap.org/wiki/Key:highway
+
 double constexpr kSpeedMotorwayKMpH = 115.37;
 double constexpr kSpeedMotorwayLinkKMpH = 75.0;
 double constexpr kSpeedTrunkKMpH = 93.89;
@@ -29,23 +37,24 @@ double constexpr kSpeedFerryMotorcarVehicleKMpH = 15.0;
 double constexpr kSpeedRailMotorcarVehicleKMpH = 25.0;
 double constexpr kSpeedShuttleTrainKMpH = 25.0;
 
-routing::VehicleModel::InitListT const s_carLimits = {
-    {{"highway", "motorway"}, kSpeedMotorwayKMpH,            true},
-    {{"highway", "trunk"}, kSpeedTrunkKMpH,                  true},
-    {{"highway", "motorway_link"}, kSpeedMotorwayLinkKMpH,   true},
-    {{"highway", "trunk_link"}, kSpeedTrunkLinkKMpH,         true},
-    {{"highway", "primary"}, kSpeedPrimaryKMpH,              true},
-    {{"highway", "primary_link"}, kSpeedPrimaryLinkKMpH,     true},
-    {{"highway", "secondary"}, kSpeedSecondaryKMpH,          true},
+routing::VehicleModel::InitListT const g_carLimitsDefault =
+{
+    {{"highway", "motorway"},       kSpeedMotorwayKMpH,      true},
+    {{"highway", "motorway_link"},  kSpeedMotorwayLinkKMpH,  true},
+    {{"highway", "trunk"},          kSpeedTrunkKMpH,         true},
+    {{"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true},
+    {{"highway", "primary"},        kSpeedPrimaryKMpH,       true},
+    {{"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true},
+    {{"highway", "secondary"},      kSpeedSecondaryKMpH,     true},
     {{"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true},
-    {{"highway", "tertiary"}, kSpeedTertiaryKMpH,            true},
-    {{"highway", "tertiary_link"}, kSpeedTertiaryLinkKMpH,   true},
-    {{"highway", "residential"}, kSpeedResidentialKMpH,      true},
-    {{"highway", "unclassified"}, kSpeedUnclassifiedKMpH,    true},
-    {{"highway", "service"}, kSpeedServiceKMpH,              true},
-    {{"highway", "living_street"}, kSpeedLivingStreetKMpH,   true},
-    {{"highway", "road"}, kSpeedRoadKMpH,                    true},
-    {{"highway", "track"}, kSpeedTrackKMpH,                  true},
+    {{"highway", "tertiary"},       kSpeedTertiaryKMpH,      true},
+    {{"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true},
+    {{"highway", "residential"},    kSpeedResidentialKMpH,   true},
+    {{"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true},
+    {{"highway", "service"},        kSpeedServiceKMpH,       true},
+    {{"highway", "living_street"},  kSpeedLivingStreetKMpH,  true},
+    {{"highway", "road"},           kSpeedRoadKMpH,          true},
+    {{"highway", "track"},          kSpeedTrackKMpH,         true},
     /// @todo: Add to classificator
     //{ {"highway", "shuttle_train"},  10 },
     //{ {"highway", "ferry"},          5  },
@@ -54,13 +63,149 @@ routing::VehicleModel::InitListT const s_carLimits = {
     //{ {"highway", "construction"},   40 },
 };
 
+routing::VehicleModel::InitListT const g_carLimitsNoLivingStreetTransit =
+{
+    {{"highway", "motorway"},       kSpeedMotorwayKMpH,      true},
+    {{"highway", "motorway_link"},  kSpeedMotorwayLinkKMpH,  true},
+    {{"highway", "trunk"},          kSpeedTrunkKMpH,         true},
+    {{"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true},
+    {{"highway", "primary"},        kSpeedPrimaryKMpH,       true},
+    {{"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true},
+    {{"highway", "secondary"},      kSpeedSecondaryKMpH,     true},
+    {{"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true},
+    {{"highway", "tertiary"},       kSpeedTertiaryKMpH,      true},
+    {{"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true},
+    {{"highway", "residential"},    kSpeedResidentialKMpH,   true},
+    {{"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true},
+    {{"highway", "service"},        kSpeedServiceKMpH,       true},
+    {{"highway", "living_street"},  kSpeedLivingStreetKMpH,  false},
+    {{"highway", "road"},           kSpeedRoadKMpH,          true},
+    {{"highway", "track"},          kSpeedTrackKMpH,         true},
+};
+
+routing::VehicleModel::InitListT const g_carLimitsNoLivingStreetAndServiceTransit =
+{
+    {{"highway", "motorway"},       kSpeedMotorwayKMpH,      true},
+    {{"highway", "motorway_link"},  kSpeedMotorwayLinkKMpH,  true},
+    {{"highway", "trunk"},          kSpeedTrunkKMpH,         true},
+    {{"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true},
+    {{"highway", "primary"},        kSpeedPrimaryKMpH,       true},
+    {{"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true},
+    {{"highway", "secondary"},      kSpeedSecondaryKMpH,     true},
+    {{"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true},
+    {{"highway", "tertiary"},       kSpeedTertiaryKMpH,      true},
+    {{"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true},
+    {{"highway", "residential"},    kSpeedResidentialKMpH,   true},
+    {{"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true},
+    {{"highway", "service"},        kSpeedServiceKMpH,       false},
+    {{"highway", "living_street"},  kSpeedLivingStreetKMpH,  false},
+    {{"highway", "road"},           kSpeedRoadKMpH,          true},
+    {{"highway", "track"},          kSpeedTrackKMpH,         true},
+};
+
+routing::VehicleModel::InitListT const g_carLimitsAustralia = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsAustria = g_carLimitsNoLivingStreetTransit;
+
+routing::VehicleModel::InitListT const g_carLimitsBelarus = g_carLimitsNoLivingStreetTransit;
+
+routing::VehicleModel::InitListT const g_carLimitsBelgium = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsBrazil = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsDenmark =
+{
+    // No track
+    {{"highway", "motorway"},       kSpeedMotorwayKMpH,      true},
+    {{"highway", "motorway_link"},  kSpeedMotorwayLinkKMpH,  true},
+    {{"highway", "trunk"},          kSpeedTrunkKMpH,         true},
+    {{"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true},
+    {{"highway", "primary"},        kSpeedPrimaryKMpH,       true},
+    {{"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true},
+    {{"highway", "secondary"},      kSpeedSecondaryKMpH,     true},
+    {{"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true},
+    {{"highway", "tertiary"},       kSpeedTertiaryKMpH,      true},
+    {{"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true},
+    {{"highway", "residential"},    kSpeedResidentialKMpH,   true},
+    {{"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true},
+    {{"highway", "service"},        kSpeedServiceKMpH,       true},
+    {{"highway", "living_street"},  kSpeedLivingStreetKMpH,  true},
+    {{"highway", "road"},           kSpeedRoadKMpH,          true},
+};
+
+routing::VehicleModel::InitListT const g_carLimitsFrance = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsFinland = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsGermany = 
+{
+    // No transit for track
+    {{"highway", "motorway"},       kSpeedMotorwayKMpH,      true},
+    {{"highway", "motorway_link"},  kSpeedMotorwayLinkKMpH,  true},
+    {{"highway", "trunk"},          kSpeedTrunkKMpH,         true},
+    {{"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true},
+    {{"highway", "primary"},        kSpeedPrimaryKMpH,       true},
+    {{"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true},
+    {{"highway", "secondary"},      kSpeedSecondaryKMpH,     true},
+    {{"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true},
+    {{"highway", "tertiary"},       kSpeedTertiaryKMpH,      true},
+    {{"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true},
+    {{"highway", "residential"},    kSpeedResidentialKMpH,   true},
+    {{"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true},
+    {{"highway", "service"},        kSpeedServiceKMpH,       true},
+    {{"highway", "living_street"},  kSpeedLivingStreetKMpH,  true},
+    {{"highway", "road"},           kSpeedRoadKMpH,          true},
+    {{"highway", "track"},          kSpeedTrackKMpH,         false},
+};
+
+routing::VehicleModel::InitListT const g_carLimitsHungary = g_carLimitsNoLivingStreetTransit;
+
+routing::VehicleModel::InitListT const g_carLimitsIceland = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsNetherlands = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsNorway = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsOman = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsPoland = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsRomania = g_carLimitsNoLivingStreetTransit;
+
+routing::VehicleModel::InitListT const g_carLimitsRussia = g_carLimitsNoLivingStreetAndServiceTransit;
+
+routing::VehicleModel::InitListT const g_carLimitsSlovakia = g_carLimitsNoLivingStreetTransit;
+
+routing::VehicleModel::InitListT const g_carLimitsSpain = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsSwitzerland = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsTurkey = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsUkraine = g_carLimitsNoLivingStreetAndServiceTransit;
+
+routing::VehicleModel::InitListT const g_carLimitsUK = g_carLimitsDefault;
+
+routing::VehicleModel::InitListT const g_carLimitsUS = g_carLimitsDefault;
+
 }  // namespace
 
 namespace routing
 {
 
 CarModel::CarModel()
-  : VehicleModel(classif(), s_carLimits)
+  : VehicleModel(classif(), g_carLimitsDefault)
+{
+  InitAdditionalRoadTypes();
+}
+
+CarModel::CarModel(VehicleModel::InitListT const & roadLimits)
+  : VehicleModel(classif(), roadLimits)
+{
+  InitAdditionalRoadTypes();
+}
+
+void CarModel::InitAdditionalRoadTypes()
 {
   vector<AdditionalRoadTags> const additionalTags = {
       {{"route", "ferry", "motorcar"}, kSpeedFerryMotorcarKMpH},
@@ -79,14 +224,52 @@ CarModel const & CarModel::AllLimitsInstance()
   return instance;
 }
 
-CarModelFactory::CarModelFactory() { m_model = make_shared<CarModel>(); }
-shared_ptr<IVehicleModel> CarModelFactory::GetVehicleModel() const { return m_model; }
-shared_ptr<IVehicleModel> CarModelFactory::GetVehicleModelForCountry(
-    string const & /* country */) const
+CarModelFactory::CarModelFactory()
 {
-  // @TODO(bykoianko) Different vehicle model for different country should be supported
-  // according to http://wiki.openstreetmap.org/wiki/OSM_tags_for_routing/Access-Restrictions.
-  // See pedestrian_model.cpp and bicycle_model.cpp for example.
-  return m_model;
+  // Names must be the same with country names from countries.txt
+  m_models[string()] = make_shared<CarModel>(g_carLimitsDefault);
+  m_models["Australia"] = make_shared<CarModel>(g_carLimitsAustralia);
+  m_models["Austria"] = make_shared<CarModel>(g_carLimitsAustria);
+  m_models["Belarus"] = make_shared<CarModel>(g_carLimitsBelarus);
+  m_models["Belgium"] = make_shared<CarModel>(g_carLimitsBelgium);
+  m_models["Brazil"] = make_shared<CarModel>(g_carLimitsBrazil);
+  m_models["Denmark"] = make_shared<CarModel>(g_carLimitsDenmark);
+  m_models["France"] = make_shared<CarModel>(g_carLimitsFrance);
+  m_models["Finland"] = make_shared<CarModel>(g_carLimitsFinland);
+  m_models["Germany"] = make_shared<CarModel>(g_carLimitsGermany);
+  m_models["Hungary"] = make_shared<CarModel>(g_carLimitsHungary);
+  m_models["Iceland"] = make_shared<CarModel>(g_carLimitsIceland);
+  m_models["Netherlands"] = make_shared<CarModel>(g_carLimitsNetherlands);
+  m_models["Norway"] = make_shared<CarModel>(g_carLimitsNorway);
+  m_models["Oman"] = make_shared<CarModel>(g_carLimitsOman);
+  m_models["Poland"] = make_shared<CarModel>(g_carLimitsPoland);
+  m_models["Romania"] = make_shared<CarModel>(g_carLimitsRomania);
+  m_models["Russian Federation"] = make_shared<CarModel>(g_carLimitsRussia);
+  m_models["Slovakia"] = make_shared<CarModel>(g_carLimitsSlovakia);
+  m_models["Spain"] = make_shared<CarModel>(g_carLimitsSpain);
+  m_models["Switzerland"] = make_shared<CarModel>(g_carLimitsSwitzerland);
+  m_models["Turkey"] = make_shared<CarModel>(g_carLimitsTurkey);
+  m_models["Ukraine"] = make_shared<CarModel>(g_carLimitsUkraine);
+  m_models["United Kingdom"] = make_shared<CarModel>(g_carLimitsUK);
+  m_models["United States of America"] = make_shared<CarModel>(g_carLimitsUS);
+}
+
+shared_ptr<IVehicleModel> CarModelFactory::GetVehicleModel() const
+{
+  auto const itr = m_models.find(string());
+  ASSERT(itr != m_models.end(), ());
+  return itr->second;
+}
+
+shared_ptr<IVehicleModel> CarModelFactory::GetVehicleModelForCountry(string const & country) const
+{
+  auto const itr = m_models.find(country);
+  if (itr != m_models.end())
+  {
+    LOG(LDEBUG, ("Car model was found:", country));
+    return itr->second;
+  }
+  LOG(LDEBUG, ("Car model wasn't found, default car model is used instead:", country));
+  return CarModelFactory::GetVehicleModel();
 }
 }  // namespace routing
diff --git a/routing_common/car_model.hpp b/routing_common/car_model.hpp
index 1f99d97b67..64270125e9 100644
--- a/routing_common/car_model.hpp
+++ b/routing_common/car_model.hpp
@@ -2,8 +2,9 @@
 
 #include "routing_common/vehicle_model.hpp"
 
-#include "std/shared_ptr.hpp"
-#include "std/string.hpp"
+#include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace routing
 {
@@ -12,8 +13,12 @@ class CarModel : public VehicleModel
 {
 public:
   CarModel();
+  CarModel(VehicleModel::InitListT const & roadLimits);
 
   static CarModel const & AllLimitsInstance();
+
+private:
+  void InitAdditionalRoadTypes();
 };
 
 class CarModelFactory : public VehicleModelFactory
@@ -22,10 +27,10 @@ public:
   CarModelFactory();
 
   // VehicleModelFactory overrides:
-  shared_ptr<IVehicleModel> GetVehicleModel() const override;
-  shared_ptr<IVehicleModel> GetVehicleModelForCountry(string const & country) const override;
+  std::shared_ptr<IVehicleModel> GetVehicleModel() const override;
+  std::shared_ptr<IVehicleModel> GetVehicleModelForCountry(std::string const & country) const override;
 
 private:
-  shared_ptr<IVehicleModel> m_model;
+  std::unordered_map<std::string, std::shared_ptr<IVehicleModel>> m_models;
 };
 }  // namespace routing
diff --git a/routing_common/pedestrian_model.cpp b/routing_common/pedestrian_model.cpp
index 7874c51d9a..399d37d22d 100644
--- a/routing_common/pedestrian_model.cpp
+++ b/routing_common/pedestrian_model.cpp
@@ -74,32 +74,6 @@ routing::VehicleModel::InitListT const g_pedestrianLimitsDefault =
 
 // All options available.
 routing::VehicleModel::InitListT const g_pedestrianLimitsAll =
-{
-  { {"highway", "trunk"},          kSpeedPedestrianKMpH,    true },
-  { {"highway", "trunk_link"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "primary"},        kSpeedPedestrianKMpH,    true },
-  { {"highway", "primary_link"},   kSpeedPedestrianKMpH,    true },
-  { {"highway", "secondary"},      kSpeedPedestrianKMpH,    true },
-  { {"highway", "secondary_link"}, kSpeedPedestrianKMpH,    true },
-  { {"highway", "tertiary"},       kSpeedPedestrianKMpH,    true },
-  { {"highway", "tertiary_link"},  kSpeedPedestrianKMpH,    true },
-  { {"highway", "service"},        kSpeedPedestrianKMpH,    true },
-  { {"highway", "unclassified"},   kSpeedPedestrianKMpH,    true },
-  { {"highway", "road"},           kSpeedPedestrianKMpH,    true },
-  { {"highway", "track"},          kSpeedPedestrianKMpH,    true },
-  { {"highway", "path"},           kSpeedPedestrianKMpH,    true },
-  { {"highway", "bridleway"},      kSpeedPedestrianKMpH,    true },
-  { {"highway", "cycleway"},       kSpeedPedestrianKMpH,    true },
-  { {"highway", "residential"},    kSpeedPedestrianKMpH,    true },
-  { {"highway", "living_street"},  kSpeedPedestrianKMpH,    true },
-  { {"highway", "steps"},          kSpeedPedestrianKMpH,    true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedPedestrianKMpH,    true },
-  { {"highway", "platform"},       kSpeedPedestrianKMpH,    true },
-};
-
-// Australia
-routing::VehicleModel::InitListT const g_pedestrianLimitsAustralia =
 {
   { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
   { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
@@ -124,8 +98,8 @@ routing::VehicleModel::InitListT const g_pedestrianLimitsAustralia =
   { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
 };
 
-// Austria
-routing::VehicleModel::InitListT const g_pedestrianLimitsAustria =
+// Same as defaults except trunk and trunk link are not allowed.
+routing::VehicleModel::InitListT const g_pedestrianLimitsNoTrunk =
 {
   { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
   { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
@@ -147,8 +121,8 @@ routing::VehicleModel::InitListT const g_pedestrianLimitsAustria =
   { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
 };
 
-// Belarus
-routing::VehicleModel::InitListT const g_pedestrianLimitsBelarus =
+// Same as defaults except cycleway is allowed.
+routing::VehicleModel::InitListT const g_pedestrianLimitsCyclewayAllowed =
 {
   { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
   { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
@@ -172,9 +146,43 @@ routing::VehicleModel::InitListT const g_pedestrianLimitsBelarus =
   { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
 };
 
+// Same as defaults except cycleway is allowed and trunk and trunk_link are not allowed.
+routing::VehicleModel::InitListT const g_pedestrianLimitsCyclewayAllowedNoTrunk =
+{
+  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
+  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
+  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
+  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
+  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
+  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
+  { {"highway", "service"},        kSpeedServiceKMpH,       true },
+  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
+  { {"highway", "road"},           kSpeedRoadKMpH,          true },
+  { {"highway", "track"},          kSpeedTrackKMpH,         true },
+  { {"highway", "path"},           kSpeedPathKMpH,          true },
+  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
+  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
+  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
+  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
+  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
+  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
+  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
+};
+
+// Australia
+routing::VehicleModel::InitListT const g_pedestrianLimitsAustralia = g_pedestrianLimitsAll;
+
+// Austria
+routing::VehicleModel::InitListT const g_pedestrianLimitsAustria = g_pedestrianLimitsNoTrunk;
+
+// Belarus
+routing::VehicleModel::InitListT const g_pedestrianLimitsBelarus = g_pedestrianLimitsCyclewayAllowed;
+
 // Belgium
 routing::VehicleModel::InitListT const g_pedestrianLimitsBelgium =
 {
+  // Trunk and trunk_link are not allowed
+  // Bridleway and cycleway are allowed
   { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
   { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
   { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
@@ -197,408 +205,64 @@ routing::VehicleModel::InitListT const g_pedestrianLimitsBelgium =
 };
 
 // Brazil
-routing::VehicleModel::InitListT const g_pedestrianLimitsBrazil =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "bridleway"},      kSpeedBridlewayKMpH,     true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsBrazil = g_pedestrianLimitsAll;
 
 // Denmark
-routing::VehicleModel::InitListT const g_pedestrianLimitsDenmark =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsDenmark = g_pedestrianLimitsCyclewayAllowedNoTrunk;
 
 // France
-routing::VehicleModel::InitListT const g_pedestrianLimitsFrance =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsFrance = g_pedestrianLimitsNoTrunk;
 
 // Finland
-routing::VehicleModel::InitListT const g_pedestrianLimitsFinland =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsFinland = g_pedestrianLimitsCyclewayAllowed;
 
 // Germany
-routing::VehicleModel::InitListT const g_pedestrianLimitsGermany =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsGermany = g_pedestrianLimitsDefault;
 
 // Hungary
-routing::VehicleModel::InitListT const g_pedestrianLimitsHungary =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsHungary = g_pedestrianLimitsNoTrunk;
+
+// Iceland
+routing::VehicleModel::InitListT const g_pedestrianLimitsIceland = g_pedestrianLimitsAll;
 
 // Netherlands
-routing::VehicleModel::InitListT const g_pedestrianLimitsNetherlands =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsNetherlands = g_pedestrianLimitsCyclewayAllowedNoTrunk;
 
 // Norway
-routing::VehicleModel::InitListT const g_pedestrianLimitsNorway =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "bridleway"},      kSpeedBridlewayKMpH,     true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsNorway = g_pedestrianLimitsAll;
+
+// Oman
+routing::VehicleModel::InitListT const g_pedestrianLimitsOman = g_pedestrianLimitsAll;
 
 // Poland
-routing::VehicleModel::InitListT const g_pedestrianLimitsPoland =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsPoland = g_pedestrianLimitsNoTrunk;
 
 // Romania
-routing::VehicleModel::InitListT const g_pedestrianLimitsRomania =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsRomania = g_pedestrianLimitsNoTrunk;
 
-// Russia
-routing::VehicleModel::InitListT const g_pedestrianLimitsRussia =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+// Russian Federation
+routing::VehicleModel::InitListT const g_pedestrianLimitsRussia = g_pedestrianLimitsCyclewayAllowed;
 
 // Slovakia
-routing::VehicleModel::InitListT const g_pedestrianLimitsSlovakia =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsSlovakia = g_pedestrianLimitsNoTrunk;
+
+// Spain
+routing::VehicleModel::InitListT const g_pedestrianLimitsSpain = g_pedestrianLimitsNoTrunk;
 
 // Switzerland
-routing::VehicleModel::InitListT const g_pedestrianLimitsSwitzerland =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsSwitzerland = g_pedestrianLimitsNoTrunk;
 
 // Turkey
-routing::VehicleModel::InitListT const g_pedestrianLimitsTurkey =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "bridleway"},      kSpeedBridlewayKMpH,     true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsTurkey = g_pedestrianLimitsAll;
 
 // Ukraine
-routing::VehicleModel::InitListT const g_pedestrianLimitsUkraine =
-{
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsUkraine = g_pedestrianLimitsNoTrunk;
 
 // United Kingdom
-routing::VehicleModel::InitListT const g_pedestrianLimitsUK =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "bridleway"},      kSpeedBridlewayKMpH,     true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+routing::VehicleModel::InitListT const g_pedestrianLimitsUK = g_pedestrianLimitsAll;
 
-// USA
-routing::VehicleModel::InitListT const g_pedestrianLimitsUS =
-{
-  { {"highway", "trunk"},          kSpeedTrunkKMpH,         true },
-  { {"highway", "trunk_link"},     kSpeedTrunkLinkKMpH,     true },
-  { {"highway", "primary"},        kSpeedPrimaryKMpH,       true },
-  { {"highway", "primary_link"},   kSpeedPrimaryLinkKMpH,   true },
-  { {"highway", "secondary"},      kSpeedSecondaryKMpH,     true },
-  { {"highway", "secondary_link"}, kSpeedSecondaryLinkKMpH, true },
-  { {"highway", "tertiary"},       kSpeedTertiaryKMpH,      true },
-  { {"highway", "tertiary_link"},  kSpeedTertiaryLinkKMpH,  true },
-  { {"highway", "service"},        kSpeedServiceKMpH,       true },
-  { {"highway", "unclassified"},   kSpeedUnclassifiedKMpH,  true },
-  { {"highway", "road"},           kSpeedRoadKMpH,          true },
-  { {"highway", "track"},          kSpeedTrackKMpH,         true },
-  { {"highway", "path"},           kSpeedPathKMpH,          true },
-  { {"highway", "bridleway"},      kSpeedBridlewayKMpH,     true },
-  { {"highway", "cycleway"},       kSpeedCyclewayKMpH,      true },
-  { {"highway", "residential"},    kSpeedResidentialKMpH,   true },
-  { {"highway", "living_street"},  kSpeedLivingStreetKMpH,  true },
-  { {"highway", "steps"},          kSpeedStepsKMpH,         true },
-  { {"highway", "pedestrian"},     kSpeedPedestrianKMpH,    true },
-  { {"highway", "footway"},        kSpeedFootwayKMpH,       true },
-  { {"highway", "platform"},       kSpeedPlatformKMpH,      true },
-};
+// United States of America
+routing::VehicleModel::InitListT const g_pedestrianLimitsUS = g_pedestrianLimitsAll;
 
 }  // namespace
 
@@ -653,6 +317,7 @@ PedestrianModel const & PedestrianModel::AllLimitsInstance()
 
 PedestrianModelFactory::PedestrianModelFactory()
 {
+  // Names must be the same with country names from countries.txt
   m_models[string()] = make_shared<PedestrianModel>(g_pedestrianLimitsDefault);
   m_models["Australia"] = make_shared<PedestrianModel>(g_pedestrianLimitsAustralia);
   m_models["Austria"] = make_shared<PedestrianModel>(g_pedestrianLimitsAustria);
@@ -664,17 +329,20 @@ PedestrianModelFactory::PedestrianModelFactory()
   m_models["Finland"] = make_shared<PedestrianModel>(g_pedestrianLimitsFinland);
   m_models["Germany"] = make_shared<PedestrianModel>(g_pedestrianLimitsGermany);
   m_models["Hungary"] = make_shared<PedestrianModel>(g_pedestrianLimitsHungary);
+  m_models["Iceland"] = make_shared<PedestrianModel>(g_pedestrianLimitsIceland);
   m_models["Netherlands"] = make_shared<PedestrianModel>(g_pedestrianLimitsNetherlands);
   m_models["Norway"] = make_shared<PedestrianModel>(g_pedestrianLimitsNorway);
+  m_models["Oman"] = make_shared<PedestrianModel>(g_pedestrianLimitsOman);
   m_models["Poland"] = make_shared<PedestrianModel>(g_pedestrianLimitsPoland);
   m_models["Romania"] = make_shared<PedestrianModel>(g_pedestrianLimitsRomania);
-  m_models["Russia"] = make_shared<PedestrianModel>(g_pedestrianLimitsRussia);
+  m_models["Russian Federation"] = make_shared<PedestrianModel>(g_pedestrianLimitsRussia);
   m_models["Slovakia"] = make_shared<PedestrianModel>(g_pedestrianLimitsSlovakia);
+  m_models["Spain"] = make_shared<PedestrianModel>(g_pedestrianLimitsSpain);
   m_models["Switzerland"] = make_shared<PedestrianModel>(g_pedestrianLimitsSwitzerland);
   m_models["Turkey"] = make_shared<PedestrianModel>(g_pedestrianLimitsTurkey);
   m_models["Ukraine"] = make_shared<PedestrianModel>(g_pedestrianLimitsUkraine);
-  m_models["UK"] = make_shared<PedestrianModel>(g_pedestrianLimitsUK);
-  m_models["US"] = make_shared<PedestrianModel>(g_pedestrianLimitsUS);
+  m_models["United Kingdom"] = make_shared<PedestrianModel>(g_pedestrianLimitsUK);
+  m_models["United States of America"] = make_shared<PedestrianModel>(g_pedestrianLimitsUS);
 }
 
 shared_ptr<IVehicleModel> PedestrianModelFactory::GetVehicleModel() const
diff --git a/routing_common/pedestrian_model.hpp b/routing_common/pedestrian_model.hpp
index 6c1e271cfd..5a36c447b9 100644
--- a/routing_common/pedestrian_model.hpp
+++ b/routing_common/pedestrian_model.hpp
@@ -2,9 +2,9 @@
 
 #include "routing_common/vehicle_model.hpp"
 
-#include "std/shared_ptr.hpp"
-#include "std/string.hpp"
-#include "std/unordered_map.hpp"
+#include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace routing
 {
@@ -36,11 +36,11 @@ public:
 
   /// @name Overrides from VehicleModelFactory.
   //@{
-  shared_ptr<IVehicleModel> GetVehicleModel() const override;
-  shared_ptr<IVehicleModel> GetVehicleModelForCountry(string const & country) const override;
+  std::shared_ptr<IVehicleModel> GetVehicleModel() const override;
+  std::shared_ptr<IVehicleModel> GetVehicleModelForCountry(std::string const & country) const override;
   //@}
 
 private:
-  unordered_map<string, shared_ptr<IVehicleModel>> m_models;
+  std::unordered_map<std::string, std::shared_ptr<IVehicleModel>> m_models;
 };
 }  // namespace routing