diff --git a/base/base_tests/geo_object_id_tests.cpp b/base/base_tests/geo_object_id_tests.cpp
index 9467d94857..6ce7e8b671 100644
--- a/base/base_tests/geo_object_id_tests.cpp
+++ b/base/base_tests/geo_object_id_tests.cpp
@@ -13,17 +13,17 @@ UNIT_TEST(GeoObjectId)
   GeoObjectId const node(GeoObjectId::Type::ObsoleteOsmNode, 12345);
   TEST_EQUAL(node.GetSerialId(), 12345ULL, ());
   TEST_EQUAL(node.GetType(), GeoObjectId::Type::ObsoleteOsmNode, ());
-  TEST_EQUAL(DebugPrint(node), "Obsolete Osm Node 12345", ());
+  TEST_EQUAL(DebugPrint(node), "Osm Node 12345", ());
 
   GeoObjectId const way(GeoObjectId::Type::ObsoleteOsmWay, 93245123456332ULL);
   TEST_EQUAL(way.GetSerialId(), 93245123456332ULL, ());
   TEST_EQUAL(way.GetType(), GeoObjectId::Type::ObsoleteOsmWay, ());
-  TEST_EQUAL(DebugPrint(way), "Obsolete Osm Way 93245123456332", ());
+  TEST_EQUAL(DebugPrint(way), "Osm Way 93245123456332", ());
 
   GeoObjectId const relation(GeoObjectId::Type::ObsoleteOsmRelation, 5);
   TEST_EQUAL(relation.GetSerialId(), 5ULL, ());
   TEST_EQUAL(relation.GetType(), GeoObjectId::Type::ObsoleteOsmRelation, ());
-  TEST_EQUAL(DebugPrint(relation), "Obsolete Osm Relation 5", ());
+  TEST_EQUAL(DebugPrint(relation), "Osm Relation 5", ());
 
   // 2^48 - 1, maximal possible serial id.
   GeoObjectId const surrogate(GeoObjectId::Type::OsmSurrogate, 281474976710655ULL);
diff --git a/base/geo_object_id.cpp b/base/geo_object_id.cpp
index 232cdae355..adaf312449 100644
--- a/base/geo_object_id.cpp
+++ b/base/geo_object_id.cpp
@@ -84,9 +84,9 @@ std::string DebugPrint(GeoObjectId::Type const & t)
   case GeoObjectId::Type::BookingComNode: return "Booking.com";
   case GeoObjectId::Type::OsmSurrogate: return "Osm Surrogate";
   case GeoObjectId::Type::Fias: return "FIAS";
-  case GeoObjectId::Type::ObsoleteOsmNode: return "Obsolete Osm Node";
-  case GeoObjectId::Type::ObsoleteOsmWay: return "Obsolete Osm Way";
-  case GeoObjectId::Type::ObsoleteOsmRelation: return "Obsolete Osm Relation";
+  case GeoObjectId::Type::ObsoleteOsmNode: return "Osm Node";
+  case GeoObjectId::Type::ObsoleteOsmWay: return "Osm Way";
+  case GeoObjectId::Type::ObsoleteOsmRelation: return "Osm Relation";
   }
   CHECK_SWITCH();
 }
diff --git a/generator/camera_node_processor.cpp b/generator/camera_node_processor.cpp
index e108957c4e..842568ffbb 100644
--- a/generator/camera_node_processor.cpp
+++ b/generator/camera_node_processor.cpp
@@ -120,14 +120,7 @@ std::string CameraNodeIntermediateDataProcessor::ValidateMaxSpeedString(std::str
   if (!ParseMaxspeedTag(maxSpeedString, speed) || !speed.IsNumeric())
     return std::string();
 
-  switch (speed.m_units)
-  {
-  case measurement_utils::Units::Metric: return strings::to_string(speed.m_speed);
-  case measurement_utils::Units::Imperial:
-    return strings::to_string(measurement_utils::MphToKmph(speed.m_speed));
-  }
-  CHECK_SWITCH();
-  return std::string();
+  return strings::to_string(measurement_utils::ToSpeedKmPH(speed.GetSpeed(), speed.GetUnits()));
 }
 
 void CameraNodeIntermediateDataProcessor::ProcessNode(OsmElement & em)
diff --git a/generator/camera_node_processor.hpp b/generator/camera_node_processor.hpp
index e49908e765..2715d92ad4 100644
--- a/generator/camera_node_processor.hpp
+++ b/generator/camera_node_processor.hpp
@@ -64,11 +64,11 @@ public:
   void SaveIndex() { m_speedCameraNodeToWays.WriteAll(); }
 
 private:
-  /// \brief Gets text with speed, returns formatted speed string in kmh.
+  /// \brief Gets text with speed, returns formatted speed string in km per hour.
   /// \param maxSpeedString - text with speed. Possible format:
-  ///                         "130" - means 130 kmh.
-  ///                         "130 mph" - means 130 mph.
-  ///                         "130 kmh" - means 130 kmh.
+  ///                         "130" - means 130 km per hour.
+  ///                         "130 mph" - means 130 mile per hour.
+  ///                         "130 kmh" - means 130 km per hour.
   /// See https://wiki.openstreetmap.org/wiki/Key:maxspeed
   /// for more details about input string.
   std::string ValidateMaxSpeedString(std::string const & maxSpeedString);
diff --git a/generator/generator_tests/altitude_test.cpp b/generator/generator_tests/altitude_test.cpp
index 10b84db2e2..8d97dd968b 100644
--- a/generator/generator_tests/altitude_test.cpp
+++ b/generator/generator_tests/altitude_test.cpp
@@ -50,7 +50,7 @@ namespace
 // Directory name for creating test mwm and temporary files.
 std::string const kTestDir = "altitude_generation_test";
 // Temporary mwm name for testing.
-std::string const kTest = "test";
+std::string const kTestMwm = "test";
 
 struct Point3D
 {
@@ -169,9 +169,9 @@ void TestAltitudesBuilding(vector<TPoint3DList> const & roads, bool hasAltitudeE
   std::string const testDirFullPath = base::JoinPath(platform.WritableDir(), kTestDir);
 
   // Building mwm without altitude section.
-  LocalCountryFile country(testDirFullPath, CountryFile(kTest), 1);
+  LocalCountryFile country(testDirFullPath, CountryFile(kTestMwm), 1);
   ScopedDir testScopedDir(kTestDir);
-  ScopedFile testScopedMwm(base::JoinPath(kTestDir, kTest + DATA_FILE_EXTENSION),
+  ScopedFile testScopedMwm(base::JoinPath(kTestDir, kTestMwm + DATA_FILE_EXTENSION),
                            ScopedFile::Mode::Create);
 
   BuildMwmWithoutAltitudes(roads, country);
diff --git a/generator/generator_tests/city_roads_tests.cpp b/generator/generator_tests/city_roads_tests.cpp
index 7fe1463d20..1c3ab117bd 100644
--- a/generator/generator_tests/city_roads_tests.cpp
+++ b/generator/generator_tests/city_roads_tests.cpp
@@ -43,7 +43,7 @@ namespace
 // Directory name for creating test mwm and temporary files.
 string const kTestDir = "city_roads_generation_test";
 // Temporary mwm name for testing.
-string const kTest = "test";
+string const kTestMwm = "test";
 
 void BuildEmptyMwm(LocalCountryFile & country)
 {
@@ -73,11 +73,11 @@ void TestCityRoadsBuilding(vector<uint64_t> && cityRoadFeatureIds)
   string const writableDir = GetPlatform().WritableDir();
 
   // Building empty mwm.
-  LocalCountryFile country(base::JoinPath(writableDir, kTestDir), CountryFile(kTest),
+  LocalCountryFile country(base::JoinPath(writableDir, kTestDir), CountryFile(kTestMwm),
                            0 /* version */);
   ScopedDir const scopedDir(kTestDir);
 
-  string const mwmRelativePath = base::JoinPath(kTestDir, kTest + DATA_FILE_EXTENSION);
+  string const mwmRelativePath = base::JoinPath(kTestDir, kTestMwm + DATA_FILE_EXTENSION);
   ScopedFile const scopedMwm(mwmRelativePath, ScopedFile::Mode::Create);
   BuildEmptyMwm(country);
 
diff --git a/generator/generator_tests/maxspeed_tests.cpp b/generator/generator_tests/maxspeed_tests.cpp
index 64bbfb14b3..dfff64e9ce 100644
--- a/generator/generator_tests/maxspeed_tests.cpp
+++ b/generator/generator_tests/maxspeed_tests.cpp
@@ -5,7 +5,7 @@
 #include "generator/maxspeed_builder.hpp"
 #include "generator/routing_helpers.hpp"
 
-#include "routing/maxspeed_serialization.hpp"
+#include "routing/maxspeeds_serialization.hpp"
 #include "routing/maxspeeds.hpp"
 
 #include "routing_common/maxspeed_conversion.hpp"
@@ -46,30 +46,23 @@ using namespace platform;
 using namespace routing;
 using namespace std;
 
-using FeatureVector = vector<vector<m2::PointD>>;
+using Features = vector<vector<m2::PointD>>;
 
 // Directory name for creating test mwm and temporary files.
 string const kTestDir = "maxspeed_generation_test";
 // Temporary mwm name for testing.
-string const kTest = "test";
+string const kTestMwm = "test";
 // File name for keeping maxspeeds.
 string const kCsv = "maxspeed.csv";
 
-void BuldGeometry(FeatureVector const & roads, LocalCountryFile & country)
+void BuildGeometry(Features const & roads, LocalCountryFile & country)
 {
   generator::tests_support::TestMwmBuilder builder(country, feature::DataHeader::country);
   for (auto const & road : roads)
     builder.Add(generator::tests_support::TestStreet(road, string(), string()));
 }
 
-void CreateTextFileByContent(string const & fileName, string const & fileContent)
-{
-  ofstream ofs(fileName);
-  TEST(ofs, ());
-  ofs << fileContent;
-}
-
-void TestMaxspeedSection(FeatureVector const & roads, string const & maxspeedCsvContent,
+void TestMaxspeedSection(Features const & roads, string const & maxspeedCsvContent,
                          map<uint32_t, base::GeoObjectId> const & featureIdToOsmId)
 {
   classificator::Load();
@@ -77,19 +70,17 @@ void TestMaxspeedSection(FeatureVector const & roads, string const & maxspeedCsv
   ScopedDir testScopedDir(kTestDir);
 
   // Writing |maxspeedCsvContent| to a file in |kTestDir|.
-  ScopedFile testScopedMaxspeedCsv(base::JoinPath(kTestDir, kCsv), ScopedFile::Mode::Create);
-  string const csvFullPath = base::JoinPath(testDirFullPath, kCsv);
-  CreateTextFileByContent(csvFullPath, maxspeedCsvContent);
+  ScopedFile testScopedMaxspeedCsv(base::JoinPath(kTestDir, kCsv), maxspeedCsvContent);
 
   // Writing |roads| to test mwm.
-  LocalCountryFile country(testDirFullPath, CountryFile(kTest), 1);
-  string const testMwm = kTest + DATA_FILE_EXTENSION;
+  LocalCountryFile country(testDirFullPath, CountryFile(kTestMwm), 1 /* version */);
+  string const testMwm = kTestMwm + DATA_FILE_EXTENSION;
   ScopedFile testScopedMwm(base::JoinPath(kTestDir, testMwm), ScopedFile::Mode::Create);
-  BuldGeometry(roads, country);
+  BuildGeometry(roads, country);
 
   // Creating maxspeed section in test.mwm.
   string const testMwmFullPath = base::JoinPath(testDirFullPath, testMwm);
-  BuildMaxspeed(testMwmFullPath, featureIdToOsmId, csvFullPath);
+  BuildMaxspeed(testMwmFullPath, featureIdToOsmId, base::JoinPath(testDirFullPath, kCsv));
 
   // Loading maxspeed section.
   FrozenDataSource dataSource;
@@ -103,9 +94,6 @@ void TestMaxspeedSection(FeatureVector const & roads, string const & maxspeedCsv
   TEST(maxspeeds, ());
 
   // Testing maxspeed section content.
-  auto const featureNumber = roads.size();
-  TEST(!maxspeeds->HasMaxspeed(static_cast<uint32_t>(featureNumber + 1)), ());
-
   OsmIdToMaxspeed osmIdToMaxspeed;
   TEST(ParseMaxspeeds(base::JoinPath(testDirFullPath, kCsv), osmIdToMaxspeed), ());
   auto processor = [&](FeatureType & f, uint32_t const & id) {
@@ -119,7 +107,6 @@ void TestMaxspeedSection(FeatureVector const & roads, string const & maxspeedCsv
     if (itMaxspeedCsv == osmIdToMaxspeed.cend())
       return; // No maxspeed for feature |id|.
 
-    TEST(maxspeeds->HasMaxspeed(id), ());
     Maxspeed const maxspeedCsv = itMaxspeedCsv->second;
     Maxspeed const maxspeedMwm = maxspeeds->GetMaxspeed(id);
 
@@ -135,9 +122,7 @@ bool ParseCsv(string const & maxspeedCsvContent, OsmIdToMaxspeed & mapping)
 {
   string const testDirFullPath = base::JoinPath(GetPlatform().WritableDir(), kTestDir);
   ScopedDir testScopedDir(kTestDir);
-
-  ScopedFile testScopedMaxspeedCsv(base::JoinPath(kTestDir, kCsv), ScopedFile::Mode::Create);
-  CreateTextFileByContent(base::JoinPath(testDirFullPath, kCsv), maxspeedCsvContent);
+  ScopedFile testScopedMaxspeedCsv(base::JoinPath(kTestDir, kCsv), maxspeedCsvContent);
 
   return ParseMaxspeeds(base::JoinPath(testDirFullPath, kCsv), mapping);
 }
@@ -152,7 +137,9 @@ UNIT_TEST(ParseMaxspeeds_Smoke)
 
 UNIT_TEST(ParseMaxspeeds1)
 {
-  string const maxspeedCsvContent = "10,Metric,60\n11,Metric,90\n";
+//  string const maxspeedCsvContent = "10,Metric,60\n11,Metric,90\n";
+  string const maxspeedCsvContent = R"(10,Metric,60
+                                       11,Metric,90)";
   OsmIdToMaxspeed const expectedMapping = {
       {base::MakeOsmWay(10), {Units::Metric, 60, kInvalidSpeed}},
       {base::MakeOsmWay(11), {Units::Metric, 90, kInvalidSpeed}}};
@@ -163,7 +150,9 @@ UNIT_TEST(ParseMaxspeeds1)
 
 UNIT_TEST(ParseMaxspeeds2)
 {
-  string const maxspeedCsvContent = "10,Metric,60,80\n11,Metric,120\n";
+//  string const maxspeedCsvContent = "10,Metric,60,80\n11,Metric,120\n";
+  string const maxspeedCsvContent = R"(10,Metric,60,80
+                                       11,Metric,120)";
   OsmIdToMaxspeed const expectedMapping = {
       {base::MakeOsmWay(10), {Units::Metric, 60, 80}},
       {base::MakeOsmWay(11), {Units::Metric, 120, kInvalidSpeed}}};
@@ -174,7 +163,10 @@ UNIT_TEST(ParseMaxspeeds2)
 
 UNIT_TEST(ParseMaxspeeds3)
 {
-  string const maxspeedCsvContent = "184467440737095516,Imperial,60,80\n184467440737095517,Metric,120\n";
+//  string const maxspeedCsvContent = "184467440737095516,Imperial,60,80\n184467440737095517,Metric,120\n";
+  string const maxspeedCsvContent = R"(184467440737095516,Imperial,60,80
+                                       184467440737095517,Metric,120)";
+
   OsmIdToMaxspeed const expectedMapping = {
       {base::MakeOsmWay(184467440737095516), {Units::Imperial, 60, 80}},
       {base::MakeOsmWay(184467440737095517), {Units::Metric, 120, kInvalidSpeed}}};
@@ -186,7 +178,8 @@ UNIT_TEST(ParseMaxspeeds3)
 UNIT_TEST(ParseMaxspeeds4)
 {
   // Note. kNoneMaxSpeed == 65534 and kWalkMaxSpeed == 65533.
-  string const maxspeedCsvContent = "1,Metric,200,65534\n2,Metric,65533\n";
+  string const maxspeedCsvContent = R"(1,Metric,200,65534
+                                       2,Metric,65533)";
   OsmIdToMaxspeed const expectedMapping = {
       {base::MakeOsmWay(1), {Units::Metric, 200, kNoneMaxSpeed}},
       {base::MakeOsmWay(2), {Units::Metric, kWalkMaxSpeed, kInvalidSpeed}}};
@@ -197,28 +190,29 @@ UNIT_TEST(ParseMaxspeeds4)
 
 UNIT_TEST(ParseMaxspeeds5)
 {
-  string const maxspeedCsvContent = "\n2,Metric,10\n";
+  string const maxspeedCsvContent = R"(
+                                       2,Metric,10)";
   OsmIdToMaxspeed osmIdToMaxspeed;
   TEST(!ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
 }
 
 UNIT_TEST(ParseMaxspeeds6)
 {
-  string const maxspeedCsvContent = "2U,Metric,10\n";
+  string const maxspeedCsvContent = R"(2U,Metric,10)";
   OsmIdToMaxspeed osmIdToMaxspeed;
   TEST(!ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
 }
 
 UNIT_TEST(ParseMaxspeeds7)
 {
-  string const maxspeedCsvContent = "2,Metric\n";
+  string const maxspeedCsvContent = R"(2,Metric)";
   OsmIdToMaxspeed osmIdToMaxspeed;
   TEST(!ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
 }
 
 UNIT_TEST(ParseMaxspeeds8)
 {
-  string const maxspeedCsvContent = "2,Metric,10,11m\n";
+  string const maxspeedCsvContent = R"(2,Metric,10,11m)";
   OsmIdToMaxspeed osmIdToMaxspeed;
   TEST(!ParseCsv(maxspeedCsvContent, osmIdToMaxspeed), ());
 }
@@ -226,7 +220,10 @@ UNIT_TEST(ParseMaxspeeds8)
 UNIT_TEST(ParseMaxspeeds_Big)
 {
   // Note. kNoneMaxSpeed == 65534.
-  string const maxspeedCsvContent = "100,Metric,200,65534\n101,Metric,60,90\n102,Metric,60\n103,Metric,90\n";
+  string const maxspeedCsvContent = R"(100,Metric,200,65534
+                                       101,Metric,60,90
+                                       102,Metric,60
+                                       103,Metric,90)";
   OsmIdToMaxspeed const expectedMapping = {
       {base::MakeOsmWay(100), {Units::Metric, 200, kNoneMaxSpeed}},
       {base::MakeOsmWay(101), {Units::Metric, 60, 90}},
@@ -239,7 +236,7 @@ UNIT_TEST(ParseMaxspeeds_Big)
 
 UNIT_TEST(MaxspeedSection_Smoke)
 {
-  FeatureVector const roads;
+  Features const roads;
   string const maxspeedCsvContent;
   map<uint32_t, base::GeoObjectId> const featureIdToOsmId;
   TestMaxspeedSection(roads, maxspeedCsvContent, featureIdToOsmId);
@@ -247,9 +244,10 @@ UNIT_TEST(MaxspeedSection_Smoke)
 
 UNIT_TEST(MaxspeedSection1)
 {
-  FeatureVector const roads = {{{0.0, 0.0}, {0.0, 1.0}, {0.0, 2.0}} /* Points of feature 0 */,
-                               {{1.0, 0.0}, {1.0, 1.0}, {1.0, 2.0}} /* Points of feature 1 */};
-  string const maxspeedCsvContent = "25258932,Metric,60\n25258943,Metric,90\n";
+  Features const roads = {{{0.0, 0.0}, {0.0, 1.0}, {0.0, 2.0}} /* Points of feature 0 */,
+                          {{1.0, 0.0}, {1.0, 1.0}, {1.0, 2.0}} /* Points of feature 1 */};
+  string const maxspeedCsvContent = R"(25258932,Metric,60
+                                       25258943,Metric,90)";
   map<uint32_t, base::GeoObjectId> const featureIdToOsmId = {
       {0 /* feature id */, base::MakeOsmWay(25258932)},
       {1 /* feature id */, base::MakeOsmWay(25258943)}};
@@ -258,10 +256,11 @@ UNIT_TEST(MaxspeedSection1)
 
 UNIT_TEST(MaxspeedSection2)
 {
-  FeatureVector const roads = {{{0.0, 0.0}, {0.0, 1.0}} /* Points of feature 0 */,
-                               {{1.0, 0.0}, {1.0, 2.0}} /* Points of feature 1 */,
-                               {{1.0, 2.0}, {1.0, 3.0}} /* Points of feature 2 */};
-  string const maxspeedCsvContent = "25258932,Metric,60,40\n32424,Metric,120\n";
+  Features const roads = {{{0.0, 0.0}, {0.0, 1.0}} /* Points of feature 0 */,
+                          {{1.0, 0.0}, {1.0, 2.0}} /* Points of feature 1 */,
+                          {{1.0, 2.0}, {1.0, 3.0}} /* Points of feature 2 */};
+  string const maxspeedCsvContent = R"(25258932,Metric,60,40
+                                       32424,Metric,120)";
   map<uint32_t, base::GeoObjectId> const featureIdToOsmId = {
       {0 /* feature id */, base::MakeOsmWay(25258932)},
       {1 /* feature id */, base::MakeOsmWay(25258943)},
@@ -271,12 +270,13 @@ UNIT_TEST(MaxspeedSection2)
 
 UNIT_TEST(MaxspeedSection3)
 {
-  FeatureVector const roads = {{{0.0, 0.0}, {0.0, 1.0}} /* Points of feature 0 */,
-                               {{1.0, 0.0}, {1.0, 2.0}} /* Points of feature 1 */,
-                               {{1.0, 2.0}, {1.0, 3.0}} /* Points of feature 2 */};
+  Features const roads = {{{0.0, 0.0}, {0.0, 1.0}} /* Points of feature 0 */,
+                          {{1.0, 0.0}, {1.0, 2.0}} /* Points of feature 1 */,
+                          {{1.0, 2.0}, {1.0, 3.0}} /* Points of feature 2 */};
   // Note. kNoneMaxSpeed == 65535 and kWalkMaxSpeed == 65534.
-  string const maxspeedCsvContent =
-      "25252,Metric,120,65534\n258943,Metric,65533\n32424,Metric,10,65533\n";
+  string const maxspeedCsvContent = R"(25252,Metric,120,65534
+                                       258943,Metric,65533
+                                       32424,Metric,10,65533)";
   map<uint32_t, base::GeoObjectId> const featureIdToOsmId = {
       {0 /* feature id */, base::MakeOsmWay(25252)},
       {1 /* feature id */, base::MakeOsmWay(258943)},
@@ -286,9 +286,10 @@ UNIT_TEST(MaxspeedSection3)
 
 UNIT_TEST(MaxspeedSection4)
 {
-  FeatureVector const roads = {{{0.0, 0.0}, {0.0, 1.0}} /* Points of feature 0 */,
-                               {{1.0, 0.0}, {0.0, 0.0}} /* Points of feature 1 */};
-  string const maxspeedCsvContent = "50000000000,Imperial,30\n50000000001,Imperial,50\n";
+  Features const roads = {{{0.0, 0.0}, {0.0, 1.0}} /* Points of feature 0 */,
+                          {{1.0, 0.0}, {0.0, 0.0}} /* Points of feature 1 */};
+  string const maxspeedCsvContent = R"(50000000000,Imperial,30
+                                       50000000001,Imperial,50)";
   map<uint32_t, base::GeoObjectId> const featureIdToOsmId = {
       {0 /* feature id */, base::MakeOsmWay(50000000000)},
       {1 /* feature id */, base::MakeOsmWay(50000000001)}};
@@ -297,16 +298,19 @@ UNIT_TEST(MaxspeedSection4)
 
 UNIT_TEST(MaxspeedSection_Big)
 {
-  FeatureVector const roads = {{{0.0, 0.0}, {0.0, 1.0}} /* Points of feature 0 */,
-                               {{1.0, 0.0}, {1.0, 2.0}} /* Points of feature 1 */,
-                               {{1.0, 2.0}, {1.0, 3.0}} /* Points of feature 2 */,
-                               {{1.0, 2.0}, {1.0, 4.0}} /* Points of feature 3 */,
-                               {{1.0, 2.0}, {2.0, 3.0}} /* Points of feature 4 */,
-                               {{1.0, 2.0}, {2.0, 7.0}} /* Points of feature 5 */,
-                               {{1.0, 2.0}, {7.0, 4.0}} /* Points of feature 6 */};
+  Features const roads = {{{0.0, 0.0}, {0.0, 1.0}} /* Points of feature 0 */,
+                          {{1.0, 0.0}, {1.0, 2.0}} /* Points of feature 1 */,
+                          {{1.0, 2.0}, {1.0, 3.0}} /* Points of feature 2 */,
+                          {{1.0, 2.0}, {1.0, 4.0}} /* Points of feature 3 */,
+                          {{1.0, 2.0}, {2.0, 3.0}} /* Points of feature 4 */,
+                          {{1.0, 2.0}, {2.0, 7.0}} /* Points of feature 5 */,
+                          {{1.0, 2.0}, {7.0, 4.0}} /* Points of feature 6 */};
   // Note. kNoneMaxSpeed == 65534.
-  string const maxspeedCsvContent =
-      "100,Imperial,100,65534\n200,Imperial,50\n300,Imperial,30\n400,Imperial,10,20\n600,"
+  string const maxspeedCsvContent = R"(100,Imperial,100,65534
+                                       200,Imperial,50
+                                       300,Imperial,30
+                                       400,Imperial,10,20
+                                       600,)"
       "Imperial,50,20\n700,Imperial,10\n";
   map<uint32_t, base::GeoObjectId> const featureIdToOsmId = {
       {0 /* feature id */, base::MakeOsmWay(100)}, {1 /* feature id */, base::MakeOsmWay(200)},
diff --git a/generator/generator_tests/restriction_test.cpp b/generator/generator_tests/restriction_test.cpp
index 1f2c680e4f..4a8efd0461 100644
--- a/generator/generator_tests/restriction_test.cpp
+++ b/generator/generator_tests/restriction_test.cpp
@@ -34,7 +34,7 @@ namespace
 // Directory name for creating test mwm and temporary files.
 string const kTestDir = "restriction_generation_test";
 // Temporary mwm name for testing.
-string const kTest = "test";
+string const kTestMwm = "test";
 string const kRestrictionFileName = "restrictions_in_osm_ids.csv";
 string const kOsmIdsToFeatureIdsName = "osm_ids_to_feature_ids" OSM2FEATURE_FILE_EXTENSION;
 
@@ -76,10 +76,10 @@ void TestRestrictionBuilding(string const & restrictionContent, string const & m
   string const writableDir = platform.WritableDir();
 
   // Building empty mwm.
-  LocalCountryFile country(base::JoinPath(writableDir, kTestDir), CountryFile(kTest),
+  LocalCountryFile country(base::JoinPath(writableDir, kTestDir), CountryFile(kTestMwm),
                            0 /* version */);
   ScopedDir const scopedDir(kTestDir);
-  string const mwmRelativePath = base::JoinPath(kTestDir, kTest + DATA_FILE_EXTENSION);
+  string const mwmRelativePath = base::JoinPath(kTestDir, kTestMwm + DATA_FILE_EXTENSION);
   ScopedFile const scopedMwm(mwmRelativePath, ScopedFile::Mode::Create);
   BuildEmptyMwm(country);
 
diff --git a/generator/generator_tests/road_access_test.cpp b/generator/generator_tests/road_access_test.cpp
index 11485641a7..84f7fcf2f0 100644
--- a/generator/generator_tests/road_access_test.cpp
+++ b/generator/generator_tests/road_access_test.cpp
@@ -41,7 +41,7 @@ using namespace std;
 namespace
 {
 string const kTestDir = "road_access_generation_test";
-string const kTest = "test";
+string const kTestMwm = "test";
 string const kRoadAccessFilename = "road_access_in_osm_ids.csv";
 string const kOsmIdsToFeatureIdsName = "osm_ids_to_feature_ids" OSM2FEATURE_FILE_EXTENSION;
 
@@ -89,10 +89,10 @@ RoadAccessCollector::RoadAccessByVehicleType SaveAndLoadRoadAccess(string const
   string const & writableDir = platform.WritableDir();
 
   // Building empty mwm.
-  LocalCountryFile country(base::JoinPath(writableDir, kTestDir), CountryFile(kTest),
+  LocalCountryFile country(base::JoinPath(writableDir, kTestDir), CountryFile(kTestMwm),
                            0 /* version */);
   ScopedDir const scopedDir(kTestDir);
-  string const mwmRelativePath = base::JoinPath(kTestDir, kTest + DATA_FILE_EXTENSION);
+  string const mwmRelativePath = base::JoinPath(kTestDir, kTestMwm + DATA_FILE_EXTENSION);
   ScopedFile const scopedMwm(mwmRelativePath, ScopedFile::Mode::Create);
   BuildTestMwmWithRoads(country);
 
diff --git a/generator/generator_tests/speed_cameras_test.cpp b/generator/generator_tests/speed_cameras_test.cpp
index 63764a284e..935e734a8a 100644
--- a/generator/generator_tests/speed_cameras_test.cpp
+++ b/generator/generator_tests/speed_cameras_test.cpp
@@ -58,7 +58,7 @@ namespace
 string const kTestDir = "speed_camera_generation_test";
 
 // Temporary mwm name for testing.
-string const kTest = "test";
+string const kTestMwm = "test";
 
 string const kSpeedCameraDataFileName = "speedcamera_in_osm_ids.bin";
 string const kOsmIdsToFeatureIdsName = "osm_ids_to_feature_ids" OSM2FEATURE_FILE_EXTENSION;
@@ -155,8 +155,8 @@ void TestSpeedCameraSectionBuilding(string const & osmContent, CameraMap const &
 
   // Step 1. Generate intermediate data.
   GenerateInfo genInfo;
-  genInfo.m_fileName = kTest;
-  genInfo.m_bucketNames.push_back(kTest);
+  genInfo.m_fileName = kTestMwm;
+  genInfo.m_bucketNames.push_back(kTestMwm);
   genInfo.m_tmpDir = testDirFullPath;
   genInfo.m_targetDir = testDirFullPath;
   genInfo.m_intermediateDir = testDirFullPath;
@@ -167,8 +167,8 @@ void TestSpeedCameraSectionBuilding(string const & osmContent, CameraMap const &
   TEST(GenerateIntermediateData(genInfo), ("Can not generate intermediate data for speed cam"));
 
   // Building empty mwm.
-  LocalCountryFile country(base::JoinPath(tmpDir, kTestDir), CountryFile(kTest), 0 /* version */);
-  string const mwmRelativePath = base::JoinPath(kTestDir, kTest + DATA_FILE_EXTENSION);
+  LocalCountryFile country(base::JoinPath(tmpDir, kTestDir), CountryFile(kTestMwm), 0 /* version */);
+  string const mwmRelativePath = base::JoinPath(kTestDir, kTestMwm + DATA_FILE_EXTENSION);
   ScopedFile const scopedMwm(mwmRelativePath, ScopedFile::Mode::Create);
 
   // Step 2. Generate binary file about cameras.
@@ -205,7 +205,7 @@ void TestSpeedCameraSectionBuilding(string const & osmContent, CameraMap const &
   }
 
   string const osmToFeatureFilename =
-    genInfo.GetTargetFileName(kTest) + OSM2FEATURE_FILE_EXTENSION;
+    genInfo.GetTargetFileName(kTestMwm) + OSM2FEATURE_FILE_EXTENSION;
 
   BuildCamerasInfo(mwmFullPath, camerasFilename, osmToFeatureFilename);
 
@@ -528,5 +528,8 @@ UNIT_TEST(MaxspeedValueToSpeedTest)
 
   TEST(!ParseMaxspeedTag("some other string", speed), ());
   TEST(!ParseMaxspeedTag("60 kmph", speed), ());
+  TEST(!ParseMaxspeedTag("1234567890 kmh", speed), ());
+  TEST(!ParseMaxspeedTag("1234567890 mph", speed), ());
+  TEST(!ParseMaxspeedTag("1234567890", speed), ());
 }
 }  // namespace
diff --git a/generator/generator_tool/generator_tool.cpp b/generator/generator_tool/generator_tool.cpp
index 4462be760d..6d893b320f 100644
--- a/generator/generator_tool/generator_tool.cpp
+++ b/generator/generator_tool/generator_tool.cpp
@@ -532,7 +532,7 @@ int main(int argc, char ** argv)
     {
       LOG(LINFO, ("Generating maxspeed section for", datFile));
       string const maxspeedFilename = genInfo.GetIntermediateFileName(MAXSPEED_FILENAME);
-      routing::BuildMaxspeed(datFile, osmToFeatureFilename, maxspeedFilename);
+      routing::BuildMaxspeedSection(datFile, osmToFeatureFilename, maxspeedFilename);
     }
 
     if (FLAGS_make_cross_mwm || FLAGS_make_transit_cross_mwm)
diff --git a/generator/maxspeed_builder.cpp b/generator/maxspeed_builder.cpp
index 2192349b72..53968c3dd3 100644
--- a/generator/maxspeed_builder.cpp
+++ b/generator/maxspeed_builder.cpp
@@ -3,7 +3,7 @@
 #include "generator/maxspeed_parser.hpp"
 #include "generator/routing_helpers.hpp"
 
-#include "routing/maxspeed_serialization.hpp"
+#include "routing/maxspeeds_serialization.hpp"
 
 #include "routing_common/maxspeed_conversion.hpp"
 
@@ -53,8 +53,8 @@ bool ParseOneSpeedValue(strings::SimpleTokenizer & iter, uint16_t & value)
 
 FeatureMaxspeed ToFeatureMaxspeed(uint32_t featureId, Maxspeed const & maxspeed)
 {
-  return FeatureMaxspeed(featureId, maxspeed.m_units, maxspeed.m_forward,
-                         maxspeed.m_backward);
+  return FeatureMaxspeed(featureId, maxspeed.GetUnits(), maxspeed.GetForward(),
+                         maxspeed.GetBackward());
 }
 
 /// \brief Collects all maxspeed tag value of specified mwm based on maxspeed.csv file.
@@ -98,7 +98,7 @@ MaxspeedMwmCollector::MaxspeedMwmCollector(
 
 vector<FeatureMaxspeed> && MaxspeedMwmCollector::StealMaxspeeds()
 {
-  CHECK(is_sorted(m_maxspeeds.cbegin(), m_maxspeeds.cend()), ());
+  CHECK(is_sorted(m_maxspeeds.cbegin(), m_maxspeeds.cend(), IsFeatureIdLess), ());
   return move(m_maxspeeds);
 }
 }  // namespace
@@ -110,38 +110,44 @@ bool ParseMaxspeeds(string const & maxspeedFilename, OsmIdToMaxspeed & osmIdToMa
   osmIdToMaxspeed.clear();
 
   ifstream stream(maxspeedFilename);
-  if (stream.fail())
+  if (!stream)
     return false;
 
   string line;
   while (getline(stream, line))
   {
     strings::SimpleTokenizer iter(line, kDelim);
+
     if (!iter)  // the line is empty
       return false;
-
     // @TODO(bykoianko) strings::to_uint64 returns not-zero value if |*iter| is equal to
     // a too long string of numbers. But ParseMaxspeeds() should return false in this case.
     uint64_t osmId = 0;
     if (!strings::to_uint64(*iter, osmId))
       return false;
     ++iter;
+
     if (!iter)
       return false;
-
     Maxspeed speed;
-    speed.m_units = StringToUnits(*iter);
+    speed.SetUnits(StringToUnits(*iter));
     ++iter;
 
-    if (!ParseOneSpeedValue(iter, speed.m_forward))
+    uint16_t forward = 0;
+    if (!ParseOneSpeedValue(iter, forward))
       return false;
 
+    speed.SetForward(forward);
+
     if (iter)
     {
       // There's backward maxspeed limit.
-      if (!ParseOneSpeedValue(iter, speed.m_backward))
+      uint16_t backward = 0;
+      if (!ParseOneSpeedValue(iter, backward))
         return false;
 
+      speed.SetBackward(backward);
+
       if (iter)
         return false;
     }
@@ -153,7 +159,7 @@ bool ParseMaxspeeds(string const & maxspeedFilename, OsmIdToMaxspeed & osmIdToMa
   return true;
 }
 
-void SerializeMaxspeed(string const & dataPath, vector<FeatureMaxspeed> && speeds)
+void SerializeMaxspeeds(string const & dataPath, vector<FeatureMaxspeed> && speeds)
 {
   if (speeds.empty())
     return;
@@ -161,21 +167,21 @@ void SerializeMaxspeed(string const & dataPath, vector<FeatureMaxspeed> && speed
   FilesContainerW cont(dataPath, FileWriter::OP_WRITE_EXISTING);
   FileWriter writer = cont.GetWriter(MAXSPEED_FILE_TAG);
 
-  MaxspeedSerializer::Serialize(speeds, writer);
-  LOG(LINFO, ("SerializeMaxspeed(", dataPath, ", ...) serialized:", speeds.size(), "maxspeed tags."));
+  MaxspeedsSerializer::Serialize(speeds, writer);
+  LOG(LINFO, ("SerializeMaxspeeds(", dataPath, ", ...) serialized:", speeds.size(), "maxspeed tags."));
 }
 
 void BuildMaxspeed(string const & dataPath, map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
                    string const & maxspeedFilename)
 {
   MaxspeedMwmCollector collector(dataPath, featureIdToOsmId, maxspeedFilename);
-  SerializeMaxspeed(dataPath, collector.StealMaxspeeds());
+  SerializeMaxspeeds(dataPath, collector.StealMaxspeeds());
 }
 
-void BuildMaxspeed(string const & dataPath, string const & osmToFeaturePath,
-                   string const & maxspeedFilename)
+void BuildMaxspeedSection(string const & dataPath, string const & osmToFeaturePath,
+                          string const & maxspeedFilename)
 {
-  LOG(LINFO, ("BuildMaxspeed(", dataPath, ",", osmToFeaturePath, ",", maxspeedFilename, ")"));
+  LOG(LINFO, ("BuildMaxspeedSection(", dataPath, ",", osmToFeaturePath, ",", maxspeedFilename, ")"));
 
   map<uint32_t, base::GeoObjectId> featureIdToOsmId;
   CHECK(ParseFeatureIdToOsmIdMapping(osmToFeaturePath, featureIdToOsmId), ());
diff --git a/generator/maxspeed_builder.hpp b/generator/maxspeed_builder.hpp
index ed2dd409ac..bbd5e9f569 100644
--- a/generator/maxspeed_builder.hpp
+++ b/generator/maxspeed_builder.hpp
@@ -1,4 +1,5 @@
 #pragma once
+
 #include "routing_common/maxspeed_conversion.hpp"
 
 #include "platform/measurement_utils.hpp"
@@ -14,12 +15,12 @@ namespace routing
 {
 using OsmIdToMaxspeed = std::map<base::GeoObjectId, Maxspeed>;
 
-/// \brief Parses csv file with path |maxspeedFilename| and keep the result in |osmIdToMaxspeed|.
+/// \brief Parses csv file with path |maxspeedFilename| and stores the result in |osmIdToMaxspeed|.
 /// \note There's a detailed description of the csv file in generator/maxspeed_collector.hpp.
 bool ParseMaxspeeds(std::string const & maxspeedFilename, OsmIdToMaxspeed & osmIdToMaxspeed);
 
 /// \brief Writes |speeds| to maxspeed section to mwm with |dataPath|.
-void SerializeMaxspeed(std::string const & dataPath, std::vector<FeatureMaxspeed> && speeds);
+void SerializeMaxspeeds(std::string const & dataPath, std::vector<FeatureMaxspeed> && speeds);
 
 void BuildMaxspeed(std::string const & dataPath,
                    std::map<uint32_t, base::GeoObjectId> const & featureIdToOsmId,
@@ -30,8 +31,8 @@ void BuildMaxspeed(std::string const & dataPath,
 /// \param maxspeedFilename file name to csv file with maxspeed tag values.
 /// \note To start building the section, the following data must be ready:
 /// 1. GenerateIntermediateData(). Saves to a file data about maxspeed tags value of road features
-/// 2. GenerateFeatures()
-/// 3. Generates geometry
-void BuildMaxspeed(std::string const & dataPath, std::string const & osmToFeaturePath,
-                   std::string const & maxspeedFilename);
+/// 2. Calls GenerateFeatures()
+/// 3. Generates geometry.
+void BuildMaxspeedSection(std::string const & dataPath, std::string const & osmToFeaturePath,
+                          std::string const & maxspeedFilename);
 }  // namespace routing
diff --git a/generator/maxspeed_collector.cpp b/generator/maxspeed_collector.cpp
index e37a00fa9f..b16a1fae53 100644
--- a/generator/maxspeed_collector.cpp
+++ b/generator/maxspeed_collector.cpp
@@ -25,12 +25,12 @@ bool ParseMaxspeedAndWriteToStream(string const & maxspeed, SpeedInUnits & speed
   if (!ParseMaxspeedTag(maxspeed, speed))
     return false;
 
-  ss << UnitsToString(speed.m_units) << "," << strings::to_string(speed.m_speed);
+  ss << UnitsToString(speed.GetUnits()) << "," << strings::to_string(speed.GetSpeed());
   return true;
 }
 }  // namespace
 
-namespace feature
+namespace generator
 {
 void MaxspeedCollector::Process(OsmElement const & p)
 {
@@ -89,7 +89,7 @@ void MaxspeedCollector::Process(OsmElement const & p)
     if (!HaveSameUnits(maxspeedForward, maxspeedBackward))
       return;
 
-    ss << "," << strings::to_string(maxspeedBackward.m_speed);
+    ss << "," << strings::to_string(maxspeedBackward.GetSpeed());
   }
 
   m_data.push_back(ss.str());
@@ -114,4 +114,4 @@ void MaxspeedCollector::Flush()
   else
     LOG(LINFO, ("Wrote", m_data.size(), "maxspeed tags to", m_filePath));
 }
-}  // namespace feature
+}  // namespace generator
diff --git a/generator/maxspeed_collector.hpp b/generator/maxspeed_collector.hpp
index 40b2cee1c3..021f8da68f 100644
--- a/generator/maxspeed_collector.hpp
+++ b/generator/maxspeed_collector.hpp
@@ -5,7 +5,7 @@
 #include <string>
 #include <vector>
 
-namespace feature
+namespace generator
 {
 /// \brief Collects all maxspeed tags value and saves them to a csv file.
 /// Every line describes maxspeed, maxspeed:forward and maxspeed:backward
@@ -47,4 +47,4 @@ private:
   std::vector<std::string> m_data;
   std::string m_filePath;
 };
-}  // namespace feature
+}  // namespace generator
diff --git a/generator/maxspeed_parser.cpp b/generator/maxspeed_parser.cpp
index 02cb680d38..8ef95eaa99 100644
--- a/generator/maxspeed_parser.cpp
+++ b/generator/maxspeed_parser.cpp
@@ -4,6 +4,7 @@
 #include "base/string_utils.hpp"
 
 #include <cctype>
+#include <limits>
 #include <unordered_map>
 
 namespace
@@ -154,15 +155,15 @@ bool ParseMaxspeedTag(string const & maxspeedValue, SpeedInUnits & speed)
 
   if (maxspeedValue == "none")
   {
-    speed.m_speed = kNoneMaxSpeed;
-    speed.m_units = Units::Metric; // It's dummy value in case of kNoneMaxSpeed
+    speed.SetSpeed(kNoneMaxSpeed);
+    speed.SetUnits(Units::Metric); // It's dummy value in case of kNoneMaxSpeed
     return true;
   }
 
   if (maxspeedValue == "walk")
   {
-    speed.m_speed = kWalkMaxSpeed;
-    speed.m_units = Units::Metric; // It's dummy value in case of kWalkMaxSpeed
+    speed.SetSpeed(kWalkMaxSpeed);
+    speed.SetUnits(Units::Metric); // It's dummy value in case of kWalkMaxSpeed
     return true;
   }
 
@@ -183,23 +184,23 @@ bool ParseMaxspeedTag(string const & maxspeedValue, SpeedInUnits & speed)
   if (maxspeedValue.size() == i ||
       strings::StartsWith(string(maxspeedValue.begin() + i, maxspeedValue.end()), "kmh"))
   {
-    int32_t kmph = 0;
-    if (!strings::to_int(speedStr.c_str(), kmph) || kmph == 0)
+    uint64_t kmph = 0;
+    if (!strings::to_uint64(speedStr.c_str(), kmph) || kmph == 0 || kmph > numeric_limits<uint16_t>::max())
       return false;
 
-    speed.m_speed = static_cast<uint16_t>(kmph);
-    speed.m_units = Units::Metric;
+    speed.SetSpeed(static_cast<uint16_t>(kmph));
+    speed.SetUnits(Units::Metric);
     return true;
   }
 
   if (strings::StartsWith(string(maxspeedValue.begin() + i, maxspeedValue.end()), "mph"))
   {
-    int32_t mph = 0;
-    if (!strings::to_int(speedStr.c_str(), mph) || mph == 0)
+    uint64_t mph = 0;
+    if (!strings::to_uint64(speedStr.c_str(), mph) || mph == 0 || mph > numeric_limits<uint16_t>::max())
       return false;
 
-    speed.m_speed = static_cast<uint16_t>(mph);
-    speed.m_units = Units::Imperial;
+    speed.SetSpeed(static_cast<uint16_t>(mph));
+    speed.SetUnits(Units::Imperial);
     return true;
   }
 
@@ -221,10 +222,10 @@ Units StringToUnits(string const & units)
 
   if (units == "Metric")
     return Units::Metric;
-  else if (units == "Imperial")
+  if (units == "Imperial")
     return Units::Imperial;
-  else
-    CHECK(false, (units));
+
+  CHECK(false, (units));
   return Units::Metric;
 }
-}  // generator
+}  // namespace generator
diff --git a/generator/maxspeed_parser.hpp b/generator/maxspeed_parser.hpp
index 223b642430..cf8a7cf74f 100644
--- a/generator/maxspeed_parser.hpp
+++ b/generator/maxspeed_parser.hpp
@@ -28,5 +28,8 @@ bool RoadCategoryToSpeed(std::string const & category, routing::SpeedInUnits & s
 bool ParseMaxspeedTag(std::string const & maxspeedValue, routing::SpeedInUnits & speed);
 
 std::string UnitsToString(measurement_utils::Units units);
+
+/// \brief Converts string to measurement_utils::Units.
+/// \note |units| should be equale to "Metric" or "Imperial".
 measurement_utils::Units StringToUnits(std::string const & units);
-}  // generator
+}  // namespace generator
diff --git a/generator/routing_helpers.hpp b/generator/routing_helpers.hpp
index a73f93f483..35986013d0 100644
--- a/generator/routing_helpers.hpp
+++ b/generator/routing_helpers.hpp
@@ -22,7 +22,7 @@ struct TagsProcessor
   RoadAccessWriter m_roadAccessWriter;
   RestrictionWriter m_restrictionWriter;
   CameraNodeProcessor m_cameraNodeWriter;
-  feature::MaxspeedCollector m_maxspeedCollector;
+  generator::MaxspeedCollector m_maxspeedCollector;
 };
 
 // Adds feature id and corresponding |osmId| to |osmIdToFeatureId|.
diff --git a/openlr/openlr_tests/decoded_path_test.cpp b/openlr/openlr_tests/decoded_path_test.cpp
index 439961fcc7..3a07f68a4f 100644
--- a/openlr/openlr_tests/decoded_path_test.cpp
+++ b/openlr/openlr_tests/decoded_path_test.cpp
@@ -34,7 +34,7 @@ using namespace std;
 namespace
 {
 string const kTestDir = "openlr_decoded_path_test";
-string const kTest = "test";
+string const kTestMwm = "test";
 
 double RoughUpToFive(double d)
 {
@@ -123,9 +123,9 @@ void WithRoad(vector<m2::PointD> const & points, Func && fn)
 
   auto const mwmPath = base::JoinPath(platform.WritableDir(), kTestDir);
 
-  LocalCountryFile country(mwmPath, CountryFile(kTest), 0 /* version */);
+  LocalCountryFile country(mwmPath, CountryFile(kTestMwm), 0 /* version */);
   ScopedDir testScopedDir(kTestDir);
-  ScopedFile testScopedMwm(base::JoinPath(kTestDir, kTest + DATA_FILE_EXTENSION),
+  ScopedFile testScopedMwm(base::JoinPath(kTestDir, kTestMwm + DATA_FILE_EXTENSION),
                            ScopedFile::Mode::Create);
 
   {
diff --git a/platform/measurement_utils.hpp b/platform/measurement_utils.hpp
index 7c9752d388..96c2f50910 100644
--- a/platform/measurement_utils.hpp
+++ b/platform/measurement_utils.hpp
@@ -27,7 +27,7 @@ inline std::string DebugPrint(Units units)
 inline double MetersToMiles(double m) { return m * 0.000621371192; }
 inline double MilesToMeters(double mi) { return mi * 1609.344; }
 inline double MphToKmph(double mph) { return MilesToMeters(mph) / 1000.0; }
-inline double KmphToMph(double kmph) { return MetersToMiles(kmph) * 1000.0; }
+inline double KmphToMph(double kmph) { return MetersToMiles(kmph * 1000.0); }
 inline double MetersToFeet(double m) { return m * 3.2808399; }
 inline double FeetToMeters(double ft) { return ft * 0.3048; }
 inline double FeetToMiles(double ft) { return ft * 5280; }
diff --git a/platform/platform_tests/measurement_tests.cpp b/platform/platform_tests/measurement_tests.cpp
index 47aced3b81..0eb20b7997 100644
--- a/platform/platform_tests/measurement_tests.cpp
+++ b/platform/platform_tests/measurement_tests.cpp
@@ -194,7 +194,7 @@ UNIT_TEST(OSMDistanceToMetersString)
   TEST_EQUAL(OSMDistanceToMetersString("15.654321", true, 1), "15.7", ());
 }
 
-UNIT_TEST(ConversionUnits)
+UNIT_TEST(UnitsConversion)
 {
   double const kEps = 0.00001;
   TEST(base::AlmostEqualAbs(MilesToMeters(MetersToMiles(1000.0)), 1000.0, kEps), ());
diff --git a/routing/CMakeLists.txt b/routing/CMakeLists.txt
index 88b5211255..37205ea6c7 100644
--- a/routing/CMakeLists.txt
+++ b/routing/CMakeLists.txt
@@ -65,8 +65,8 @@ set(
   loaded_path_segment.hpp
   maxspeeds.cpp
   maxspeeds.hpp
-  maxspeed_serialization.cpp
-  maxspeed_serialization.hpp
+  maxspeeds_serialization.cpp
+  maxspeeds_serialization.hpp
   nearest_edge_finder.cpp
   nearest_edge_finder.hpp
   online_absent_fetcher.cpp
diff --git a/routing/geometry.cpp b/routing/geometry.cpp
index 1e89ca9142..1ca21a5a7e 100644
--- a/routing/geometry.cpp
+++ b/routing/geometry.cpp
@@ -137,8 +137,8 @@ RoadGeometry::RoadGeometry(bool oneWay, double weightSpeedKMpH, double etaSpeedK
                            Points const & points)
   : m_forwardSpeed{weightSpeedKMpH, etaSpeedKMpH}
   , m_backwardSpeed(m_forwardSpeed)
-  , m_isOneWay{oneWay}
-  , m_valid{true}
+  , m_isOneWay(oneWay)
+  , m_valid(true)
 {
   ASSERT_GREATER(weightSpeedKMpH, 0.0, ());
   ASSERT_GREATER(etaSpeedKMpH, 0.0, ());
diff --git a/routing/maxspeed_serialization.cpp b/routing/maxspeed_serialization.cpp
deleted file mode 100644
index ad208a1402..0000000000
--- a/routing/maxspeed_serialization.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "routing/maxspeed_serialization.hpp"
-
-namespace routing
-{
-void GetForwardMaxspeedStats(std::vector<FeatureMaxspeed> const & speeds,
-                             size_t & forwardMaxspeedsNumber, uint32_t & maxForwardFeatureId)
-{
-  for (auto const & s : speeds)
-  {
-    if (!s.IsBidirectional())
-    {
-      ++forwardMaxspeedsNumber;
-      maxForwardFeatureId = s.GetFeatureId();
-    }
-  }
-}
-
-void CheckSpeeds(std::vector<FeatureMaxspeed> const & speeds)
-{
-  CHECK(std::is_sorted(speeds.cbegin(), speeds.cend()), ());
-  CHECK(std::adjacent_find(speeds.cbegin(), speeds.cend(),
-                           [](auto const & lhs, auto const & rhs) {
-                             return lhs.GetFeatureId() == rhs.GetFeatureId();
-                           }) == speeds.cend(),
-        ("SpeedMacro feature ids should be unique."));
-}
-}  // namespace routing
diff --git a/routing/maxspeeds.cpp b/routing/maxspeeds.cpp
index 9c96347760..7b912b92bf 100644
--- a/routing/maxspeeds.cpp
+++ b/routing/maxspeeds.cpp
@@ -1,6 +1,6 @@
 #include "routing/maxspeeds.hpp"
 
-#include "routing/maxspeed_serialization.hpp"
+#include "routing/maxspeeds_serialization.hpp"
 
 #include "indexer/data_source.hpp"
 
@@ -20,11 +20,6 @@ bool Maxspeeds::IsEmpty() const
   return m_forwardMaxspeedsTable.size() == 0 && m_bidirectionalMaxspeeds.empty();
 }
 
-bool Maxspeeds::HasMaxspeed(uint32_t fid) const
-{
-  return HasForwardMaxspeed(fid) || HasBidirectionalMaxspeed(fid);
-}
-
 Maxspeed Maxspeeds::GetMaxspeed(uint32_t fid) const
 {
   // Forward only maxspeeds.
@@ -36,16 +31,17 @@ Maxspeed Maxspeeds::GetMaxspeed(uint32_t fid) const
     CHECK(GetMaxspeedConverter().IsValidMacro(forwardMaxspeedMacro), ());
     auto const forwardMaxspeed =
         GetMaxspeedConverter().MacroToSpeed(static_cast<SpeedMacro>(forwardMaxspeedMacro));
-    return {forwardMaxspeed.m_units, forwardMaxspeed.m_speed, kInvalidSpeed};
+    return {forwardMaxspeed.GetUnits(), forwardMaxspeed.GetSpeed(), kInvalidSpeed};
   }
 
   // Bidirectional maxspeeds.
   auto const range = std::equal_range(
       m_bidirectionalMaxspeeds.cbegin(), m_bidirectionalMaxspeeds.cend(),
-      FeatureMaxspeed(fid, measurement_utils::Units::Metric, kInvalidSpeed, kInvalidSpeed));
+      FeatureMaxspeed(fid, measurement_utils::Units::Metric, kInvalidSpeed, kInvalidSpeed),
+      IsFeatureIdLess);
 
   if (range.second == range.first)
-    return {}; // No maxspeed for |fid| is set. Returns an invalid Maxspeed instance.
+    return Maxspeed(); // No maxspeed for |fid| is set. Returns an invalid Maxspeed instance.
 
   CHECK_EQUAL(range.second - range.first, 1, ());
   return range.first->GetMaxspeed();
@@ -60,20 +56,23 @@ bool Maxspeeds::HasBidirectionalMaxspeed(uint32_t fid) const
 {
   return std::binary_search(
       m_bidirectionalMaxspeeds.cbegin(), m_bidirectionalMaxspeeds.cend(),
-      FeatureMaxspeed(fid, measurement_utils::Units::Metric, kInvalidSpeed, kInvalidSpeed));
+      FeatureMaxspeed(fid, measurement_utils::Units::Metric, kInvalidSpeed, kInvalidSpeed),
+      IsFeatureIdLess);
 }
 
 void LoadMaxspeeds(FilesContainerR::TReader const & reader, Maxspeeds & maxspeeds)
 {
   ReaderSource<FilesContainerR::TReader> src(reader);
-  MaxspeedSerializer::Deserialize(src, maxspeeds);
+  MaxspeedsSerializer::Deserialize(src, maxspeeds);
 }
 
 std::unique_ptr<Maxspeeds> LoadMaxspeeds(DataSource const & dataSource,
                                          MwmSet::MwmHandle const & handle)
 {
   auto maxspeeds = std::make_unique<Maxspeeds>();
-  auto const & mwmValue = *handle.GetValue<MwmValue>();
+  auto const value = handle.GetValue<MwmValue>();
+  CHECK(value, ());
+  auto const & mwmValue = *value;
   if (!mwmValue.m_cont.IsExist(MAXSPEED_FILE_TAG))
     return maxspeeds;
 
@@ -85,6 +84,7 @@ std::unique_ptr<Maxspeeds> LoadMaxspeeds(DataSource const & dataSource,
   {
     LOG(LERROR, ("File", mwmValue.GetCountryFileName(), "Error while reading", MAXSPEED_FILE_TAG,
         "section.", e.Msg()));
+    return std::make_unique<Maxspeeds>();
   }
 
   return maxspeeds;
diff --git a/routing/maxspeeds.hpp b/routing/maxspeeds.hpp
index 5b0cf539e7..4c1147c185 100644
--- a/routing/maxspeeds.hpp
+++ b/routing/maxspeeds.hpp
@@ -19,20 +19,15 @@ class DataSource;
 
 namespace routing
 {
-class MaxspeedSerializer;
+class MaxspeedsSerializer;
 
 class Maxspeeds
 {
-  friend class MaxspeedSerializer;
-
+  friend class MaxspeedsSerializer;
 public:
   /// \returns false if there's no maxspeeds (forward or bidirectional) and true otherwise.
   bool IsEmpty() const;
 
-  /// \returns true if there's a maxspeed for feature id |fid| and false otherwise.
-  /// \note if there's no maxspeed section returns false for every |fid|.
-  bool HasMaxspeed(uint32_t fid) const;
-
   /// \returns Maxspeed for feature id |fid|. If there's no Maxspeed value for |fid|
   /// returns an invalid Maxspeed value.
   Maxspeed GetMaxspeed(uint32_t fid) const;
diff --git a/routing/maxspeeds_serialization.cpp b/routing/maxspeeds_serialization.cpp
new file mode 100644
index 0000000000..28cdf505f2
--- /dev/null
+++ b/routing/maxspeeds_serialization.cpp
@@ -0,0 +1,17 @@
+#include "routing/maxspeeds_serialization.hpp"
+
+namespace routing
+{
+void GetForwardMaxspeedStats(std::vector<FeatureMaxspeed> const & speeds,
+                             size_t & forwardMaxspeedsNumber, uint32_t & maxForwardFeatureId)
+{
+  for (auto const & s : speeds)
+  {
+    if (!s.IsBidirectional())
+    {
+      ++forwardMaxspeedsNumber;
+      maxForwardFeatureId = s.GetFeatureId();
+    }
+  }
+}
+}  // namespace routing
diff --git a/routing/maxspeed_serialization.hpp b/routing/maxspeeds_serialization.hpp
similarity index 93%
rename from routing/maxspeed_serialization.hpp
rename to routing/maxspeeds_serialization.hpp
index cfff9fec4d..e8de1fb3bd 100644
--- a/routing/maxspeed_serialization.hpp
+++ b/routing/maxspeeds_serialization.hpp
@@ -12,6 +12,7 @@
 
 #include "base/assert.hpp"
 #include "base/logging.hpp"
+#include "base/stl_helpers.hpp"
 
 #include <algorithm>
 #include <cstdint>
@@ -24,7 +25,6 @@ namespace routing
 {
 void GetForwardMaxspeedStats(std::vector<FeatureMaxspeed> const & speeds,
                              size_t & forwardMaxspeedsNumber, uint32_t & maxForwardFeatureId);
-void CheckSpeeds(std::vector<FeatureMaxspeed> const & speeds);
 
 /// \brief
 /// Section name: "maxspeed".
@@ -34,15 +34,16 @@ void CheckSpeeds(std::vector<FeatureMaxspeed> const & speeds);
 /// * elias_fano with feature ids which have maxspeed tag in forward direction only
 /// * SimpleDenseCoding with code of maxspeed
 /// * table with vector with feature ids and maxspeeds which have maxspeed for both directions.
-class MaxspeedSerializer
+class MaxspeedsSerializer
 {
 public:
-  MaxspeedSerializer() = delete;
+  MaxspeedsSerializer() = delete;
 
   template <class Sink>
   static void Serialize(std::vector<FeatureMaxspeed> const & speeds, Sink & sink)
   {
-    CheckSpeeds(speeds);
+    CHECK(base::IsSortedAndUnique(speeds.cbegin(), speeds.cend(), IsFeatureIdLess),
+          ("SpeedMacro feature ids should be unique."));
 
     auto const startOffset = sink.Pos();
     Header header;
@@ -125,8 +126,8 @@ public:
   static void Deserialize(Source & src, Maxspeeds & maxspeeds)
   {
     // Note. Now it's assumed that only little-endian architectures are supported.
-    // (See a check at the beginning of generator_tools.) If it's nessacery to support
-    // big-indian architectures code below should be modified.
+    // (See a check at the beginning of main method in generator_tools.cpp) If it's necessary
+    // to support big-endian architectures code below should be modified.
     CHECK(maxspeeds.IsEmpty(), ());
 
     Header header;
@@ -166,20 +167,18 @@ public:
 
       measurement_utils::Units units = measurement_utils::Units::Metric;
       if (forwardSpeed.IsNumeric())
-        units = forwardSpeed.m_units;
+        units = forwardSpeed.GetUnits();
       else if (backwardSpeed.IsNumeric())
-        units = backwardSpeed.m_units;
+        units = backwardSpeed.GetUnits();
       // Note. If neither |forwardSpeed| nor |backwardSpeed| are numeric it means
       // both of them have value "walk" or "none". So the units are not relevant for this case.
 
-      maxspeeds.m_bidirectionalMaxspeeds.emplace_back(fid, units, forwardSpeed.m_speed,
-                                                      backwardSpeed.m_speed);
+      maxspeeds.m_bidirectionalMaxspeeds.emplace_back(fid, units, forwardSpeed.GetSpeed(),
+                                                      backwardSpeed.GetSpeed());
     }
   }
 
 private:
-  static uint16_t constexpr kLastVersion = 0;
-
   struct Header
   {
   public:
@@ -211,6 +210,8 @@ private:
     uint32_t m_bidirectionalMaxspeedNumber = 0;
   };
 
+  static uint16_t constexpr kLastVersion = 0;
+
   static_assert(sizeof(Header) == 16, "Wrong header size of maxspeed section.");
 };
 }  // namespace routing
diff --git a/routing/routing_tests/maxspeed_tests.cpp b/routing/routing_tests/maxspeed_tests.cpp
index 74aa4b820d..5626d69372 100644
--- a/routing/routing_tests/maxspeed_tests.cpp
+++ b/routing/routing_tests/maxspeed_tests.cpp
@@ -1,6 +1,6 @@
 #include "testing/testing.hpp"
 
-#include "routing/maxspeed_serialization.hpp"
+#include "routing/maxspeeds_serialization.hpp"
 #include "routing/maxspeeds.hpp"
 
 #include "routing_common/maxspeed_conversion.hpp"
@@ -26,20 +26,17 @@ void TestMaxspeedSerialization(std::vector<FeatureMaxspeed> const & speeds)
   vector<char> buffer;
   MemWriter<vector<char>> w(buffer);
 
-  MaxspeedSerializer::Serialize(speeds, w);
+  MaxspeedsSerializer::Serialize(speeds, w);
 
   size_t const sz = buffer.size();
 
   MemReader r(buffer.data(), sz);
   ReaderSource<MemReader> src(r);
   Maxspeeds maxspeeds;
-  MaxspeedSerializer::Deserialize(src, maxspeeds);
+  MaxspeedsSerializer::Deserialize(src, maxspeeds);
 
   for (auto const s : speeds)
-  {
-    TEST(maxspeeds.HasMaxspeed(s.GetFeatureId()), (s));
     TEST_EQUAL(maxspeeds.GetMaxspeed(s.GetFeatureId()), s.GetMaxspeed(), (s));
-  }
 }
 
 UNIT_TEST(MaxspeedConverter)
@@ -62,18 +59,18 @@ UNIT_TEST(MaxspeedConverter)
   TEST_EQUAL(conv.SpeedToMacro(SpeedInUnits(kInvalidSpeed, Units::Metric)), SpeedMacro::Undefined, ());
   TEST_EQUAL(conv.SpeedToMacro(SpeedInUnits(kNoneMaxSpeed, Units::Metric)), SpeedMacro::None, ());
   TEST_EQUAL(conv.SpeedToMacro(SpeedInUnits(kWalkMaxSpeed, Units::Metric)), SpeedMacro::Walk, ());
-  TEST_EQUAL(conv.SpeedToMacro(SpeedInUnits(60, Units::Metric)), SpeedMacro::Speed60kph, ());
-  TEST_EQUAL(conv.SpeedToMacro(SpeedInUnits(90, Units::Metric)), SpeedMacro::Speed90kph, ());
-  TEST_EQUAL(conv.SpeedToMacro(SpeedInUnits(30, Units::Imperial)), SpeedMacro::Speed30mph, ());
+  TEST_EQUAL(conv.SpeedToMacro(SpeedInUnits(60, Units::Metric)), SpeedMacro::Speed60KmPH, ());
+  TEST_EQUAL(conv.SpeedToMacro(SpeedInUnits(90, Units::Metric)), SpeedMacro::Speed90KmPH, ());
+  TEST_EQUAL(conv.SpeedToMacro(SpeedInUnits(30, Units::Imperial)), SpeedMacro::Speed30MPH, ());
   TEST_EQUAL(conv.SpeedToMacro(SpeedInUnits(33, Units::Metric)), SpeedMacro::Undefined, ());
 
   // Test on conversion some maxspeed to macro to value.
   TEST_EQUAL(conv.MacroToSpeed(SpeedMacro::Undefined), SpeedInUnits(kInvalidSpeed, Units::Metric), ());
   TEST_EQUAL(conv.MacroToSpeed(SpeedMacro::None), SpeedInUnits(kNoneMaxSpeed, Units::Metric), ());
   TEST_EQUAL(conv.MacroToSpeed(SpeedMacro::Walk), SpeedInUnits(kWalkMaxSpeed, Units::Metric), ());
-  TEST_EQUAL(conv.MacroToSpeed(SpeedMacro::Speed60kph), SpeedInUnits(60, Units::Metric), ());
-  TEST_EQUAL(conv.MacroToSpeed(SpeedMacro::Speed90kph), SpeedInUnits(90, Units::Metric), ());
-  TEST_EQUAL(conv.MacroToSpeed(SpeedMacro::Speed30mph), SpeedInUnits(30, Units::Imperial), ());
+  TEST_EQUAL(conv.MacroToSpeed(SpeedMacro::Speed60KmPH), SpeedInUnits(60, Units::Metric), ());
+  TEST_EQUAL(conv.MacroToSpeed(SpeedMacro::Speed90KmPH), SpeedInUnits(90, Units::Metric), ());
+  TEST_EQUAL(conv.MacroToSpeed(SpeedMacro::Speed30MPH), SpeedInUnits(30, Units::Imperial), ());
 
   // Test on IsValidMacro() method.
   TEST(!conv.IsValidMacro(0), ());
diff --git a/routing/routing_tests/nearest_edge_finder_tests.cpp b/routing/routing_tests/nearest_edge_finder_tests.cpp
index fe44d91aab..86af46d1ff 100644
--- a/routing/routing_tests/nearest_edge_finder_tests.cpp
+++ b/routing/routing_tests/nearest_edge_finder_tests.cpp
@@ -2,9 +2,10 @@
 
 #include "routing/routing_tests/road_graph_builder.hpp"
 
-#include "routing_common/maxspeed_conversion.hpp"
 #include "routing/nearest_edge_finder.hpp"
 
+#include "routing_common/maxspeed_conversion.hpp"
+
 #include "base/checked_cast.hpp"
 
 using namespace routing;
diff --git a/routing_common/car_model.hpp b/routing_common/car_model.hpp
index 57f8ce05ed..05a7c41b37 100644
--- a/routing_common/car_model.hpp
+++ b/routing_common/car_model.hpp
@@ -11,7 +11,7 @@ public:
   CarModel();
   CarModel(VehicleModel::LimitsInitList const & roadLimits);
 
-  // VehicleModelInterface overrides
+  // VehicleModelInterface overrides:
   SpeedKMpH GetSpeed(FeatureType & f, SpeedParams const & speedParams) const override;
   double GetOffroadSpeed() const override;
 
diff --git a/routing_common/maxspeed_conversion.cpp b/routing_common/maxspeed_conversion.cpp
index e504aa54c1..23f7ec5906 100644
--- a/routing_common/maxspeed_conversion.cpp
+++ b/routing_common/maxspeed_conversion.cpp
@@ -1,10 +1,15 @@
 #include "routing_common/maxspeed_conversion.hpp"
 
+#include "base/assert.hpp"
+
 #include <sstream>
+#include <tuple>
 #include <utility>
+#include <vector>
 
 namespace routing
 {
+using namespace std;
 using namespace measurement_utils;
 
 // SpeedInUnits ------------------------------------------------------------------------------------
@@ -15,8 +20,7 @@ bool SpeedInUnits::operator==(SpeedInUnits const & rhs) const
 
 bool SpeedInUnits::operator<(SpeedInUnits const & rhs) const
 {
-  return (m_units == Units::Metric ? m_speed : MphToKmph(m_speed)) <
-         (rhs.m_units == Units::Metric ? rhs.m_speed : MphToKmph(rhs.m_speed));
+  return ToSpeedKmPH(m_speed, m_units) < ToSpeedKmPH(rhs.m_speed, rhs.m_units);
 }
 
 bool SpeedInUnits::IsNumeric() const
@@ -25,6 +29,11 @@ bool SpeedInUnits::IsNumeric() const
 }
 
 // Maxspeed ----------------------------------------------------------------------------------------
+Maxspeed::Maxspeed(Units units, uint16_t forward, uint16_t backward)
+  : m_units(units), m_forward(forward), m_backward(backward)
+{
+}
+
 bool Maxspeed::operator==(Maxspeed const & rhs) const
 {
   return m_units == rhs.m_units && m_forward == rhs.m_forward && m_backward == rhs.m_backward;
@@ -37,6 +46,9 @@ uint16_t Maxspeed::GetSpeedInUnits(bool forward) const
 
 uint16_t Maxspeed::GetSpeedKmPH(bool forward) const
 {
+  uint16_t constexpr kNoneSpeedLimitKmPH = 1000;
+  uint16_t constexpr kWalkSpeedLimitKmPH = 6;
+
   auto speedInUnits = GetSpeedInUnits(forward);
   if (speedInUnits == kInvalidSpeed)
     return kInvalidSpeed; // That means IsValid() returns false.
@@ -46,11 +58,12 @@ uint16_t Maxspeed::GetSpeedKmPH(bool forward) const
 
   // A feature is marked as a feature without any speed limits. (maxspeed=="none").
   if (kNoneMaxSpeed)
-    return 1000; // km per hour
+    return kNoneSpeedLimitKmPH;
 
-  // A feature is marked the a driver should drive with walking speed on it. (maxspeed=="walk").
+  // If a feature is marked with the maxspeed=="walk" tag (speed == kWalkMaxSpeed) a driver
+  // should drive with a speed of a walking person.
   if (kWalkMaxSpeed)
-    return 6; // km per hour
+    return kWalkSpeedLimitKmPH;
 
   CHECK(false, ("Method IsNumeric() returns something wrong."));
 }
@@ -58,7 +71,7 @@ uint16_t Maxspeed::GetSpeedKmPH(bool forward) const
 // FeatureMaxspeed ---------------------------------------------------------------------------------
 FeatureMaxspeed::FeatureMaxspeed(uint32_t fid, measurement_utils::Units units, uint16_t forward,
                                  uint16_t backward /* = kInvalidSpeed */) noexcept
-  : m_featureId(fid), m_maxspeed({units, forward, backward})
+  : m_featureId(fid), m_maxspeed(units, forward, backward)
 {
 }
 
@@ -69,165 +82,171 @@ bool FeatureMaxspeed::operator==(FeatureMaxspeed const & rhs) const
 
 SpeedInUnits FeatureMaxspeed::GetForwardSpeedInUnits() const
 {
-  return SpeedInUnits(GetMaxspeed().m_forward, GetMaxspeed().m_units);
+  return SpeedInUnits(GetMaxspeed().GetForward(), GetMaxspeed().GetUnits());
 }
 
 SpeedInUnits FeatureMaxspeed::GetBackwardSpeedInUnits() const
 {
-  return SpeedInUnits(GetMaxspeed().m_backward, GetMaxspeed().m_units);
+  return SpeedInUnits(GetMaxspeed().GetBackward(), GetMaxspeed().GetUnits());
 }
 
 // MaxspeedConverter -------------------------------------------------------------------------------
 MaxspeedConverter::MaxspeedConverter()
 {
-  // Special values.
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Undefined)] = SpeedInUnits(kInvalidSpeed, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::None)] = SpeedInUnits(kNoneMaxSpeed, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Walk)] = SpeedInUnits(kWalkMaxSpeed, Units::Metric);
+  vector<tuple<SpeedMacro, uint16_t, Units>> const table = {
+      // Special values.
+      {SpeedMacro::Undefined, kInvalidSpeed /* speed */, Units::Metric},
+      {SpeedMacro::None, kNoneMaxSpeed /* speed */, Units::Metric},
+      {SpeedMacro::Walk, kWalkMaxSpeed /* speed */, Units::Metric},
 
-  // Km per hour.
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed1kph)] = SpeedInUnits(1, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed2kph)] = SpeedInUnits(2, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed3kph)] = SpeedInUnits(3, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed4kph)] = SpeedInUnits(4, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed5kph)] = SpeedInUnits(5, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed6kph)] = SpeedInUnits(6, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed7kph)] = SpeedInUnits(7, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed8kph)] = SpeedInUnits(8, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed9kph)] = SpeedInUnits(9, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed10kph)] = SpeedInUnits(10, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed11kph)] = SpeedInUnits(11, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed12kph)] = SpeedInUnits(12, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed13kph)] = SpeedInUnits(13, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed14kph)] = SpeedInUnits(14, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed15kph)] = SpeedInUnits(15, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed16kph)] = SpeedInUnits(16, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed18kph)] = SpeedInUnits(18, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed20kph)] = SpeedInUnits(20, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed22kph)] = SpeedInUnits(22, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed25kph)] = SpeedInUnits(25, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed24kph)] = SpeedInUnits(24, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed28kph)] = SpeedInUnits(28, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed30kph)] = SpeedInUnits(30, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed32kph)] = SpeedInUnits(32, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed35kph)] = SpeedInUnits(35, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed36kph)] = SpeedInUnits(36, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed39kph)] = SpeedInUnits(39, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed40kph)] = SpeedInUnits(40, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed45kph)] = SpeedInUnits(45, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed50kph)] = SpeedInUnits(50, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed55kph)] = SpeedInUnits(55, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed56kph)] = SpeedInUnits(56, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed60kph)] = SpeedInUnits(60, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed64kph)] = SpeedInUnits(64, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed65kph)] = SpeedInUnits(65, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed70kph)] = SpeedInUnits(70, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed72kph)] = SpeedInUnits(72, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed75kph)] = SpeedInUnits(75, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed80kph)] = SpeedInUnits(80, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed82kph)] = SpeedInUnits(82, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed85kph)] = SpeedInUnits(85, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed89kph)] = SpeedInUnits(89, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed90kph)] = SpeedInUnits(90, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed93kph)] = SpeedInUnits(93, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed95kph)] = SpeedInUnits(95, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed96kph)] = SpeedInUnits(96, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed100kph)] = SpeedInUnits(100, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed104kph)] = SpeedInUnits(104, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed105kph)] = SpeedInUnits(105, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed106kph)] = SpeedInUnits(106, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed110kph)] = SpeedInUnits(110, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed112kph)] = SpeedInUnits(112, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed115kph)] = SpeedInUnits(115, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed120kph)] = SpeedInUnits(120, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed125kph)] = SpeedInUnits(125, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed127kph)] = SpeedInUnits(127, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed130kph)] = SpeedInUnits(130, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed135kph)] = SpeedInUnits(135, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed140kph)] = SpeedInUnits(140, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed141kph)] = SpeedInUnits(141, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed145kph)] = SpeedInUnits(145, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed150kph)] = SpeedInUnits(150, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed155kph)] = SpeedInUnits(155, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed160kph)] = SpeedInUnits(160, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed165kph)] = SpeedInUnits(165, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed170kph)] = SpeedInUnits(170, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed177kph)] = SpeedInUnits(177, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed180kph)] = SpeedInUnits(180, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed185kph)] = SpeedInUnits(185, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed190kph)] = SpeedInUnits(190, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed193kph)] = SpeedInUnits(193, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed195kph)] = SpeedInUnits(195, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed200kph)] = SpeedInUnits(200, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed201kph)] = SpeedInUnits(201, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed210kph)] = SpeedInUnits(210, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed217kph)] = SpeedInUnits(217, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed220kph)] = SpeedInUnits(220, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed230kph)] = SpeedInUnits(230, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed240kph)] = SpeedInUnits(240, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed250kph)] = SpeedInUnits(250, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed260kph)] = SpeedInUnits(260, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed270kph)] = SpeedInUnits(270, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed275kph)] = SpeedInUnits(275, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed280kph)] = SpeedInUnits(280, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed285kph)] = SpeedInUnits(285, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed300kph)] = SpeedInUnits(300, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed305kph)] = SpeedInUnits(305, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed310kph)] = SpeedInUnits(310, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed320kph)] = SpeedInUnits(320, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed350kph)] = SpeedInUnits(350, Units::Metric);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed380kph)] = SpeedInUnits(380, Units::Metric);
+      // Km per hour.
+      {SpeedMacro::Speed1KmPH, 1 /* speed */, Units::Metric},
+      {SpeedMacro::Speed2KmPH, 2 /* speed */, Units::Metric},
+      {SpeedMacro::Speed3KmPH, 3 /* speed */, Units::Metric},
+      {SpeedMacro::Speed4KmPH, 4 /* speed */, Units::Metric},
+      {SpeedMacro::Speed5KmPH, 5 /* speed */, Units::Metric},
+      {SpeedMacro::Speed6KmPH, 6 /* speed */, Units::Metric},
+      {SpeedMacro::Speed7KmPH, 7 /* speed */, Units::Metric},
+      {SpeedMacro::Speed8KmPH, 8 /* speed */, Units::Metric},
+      {SpeedMacro::Speed9KmPH, 9 /* speed */, Units::Metric},
+      {SpeedMacro::Speed10KmPH, 10 /* speed */, Units::Metric},
+      {SpeedMacro::Speed11KmPH, 11 /* speed */, Units::Metric},
+      {SpeedMacro::Speed12KmPH, 12 /* speed */, Units::Metric},
+      {SpeedMacro::Speed13KmPH, 13 /* speed */, Units::Metric},
+      {SpeedMacro::Speed14KmPH, 14 /* speed */, Units::Metric},
+      {SpeedMacro::Speed15KmPH, 15 /* speed */, Units::Metric},
+      {SpeedMacro::Speed16KmPH, 16 /* speed */, Units::Metric},
+      {SpeedMacro::Speed18KmPH, 18 /* speed */, Units::Metric},
+      {SpeedMacro::Speed20KmPH, 20 /* speed */, Units::Metric},
+      {SpeedMacro::Speed22KmPH, 22 /* speed */, Units::Metric},
+      {SpeedMacro::Speed25KmPH, 25 /* speed */, Units::Metric},
+      {SpeedMacro::Speed24KmPH, 24 /* speed */, Units::Metric},
+      {SpeedMacro::Speed28KmPH, 28 /* speed */, Units::Metric},
+      {SpeedMacro::Speed30KmPH, 30 /* speed */, Units::Metric},
+      {SpeedMacro::Speed32KmPH, 32 /* speed */, Units::Metric},
+      {SpeedMacro::Speed35KmPH, 35 /* speed */, Units::Metric},
+      {SpeedMacro::Speed36KmPH, 36 /* speed */, Units::Metric},
+      {SpeedMacro::Speed39KmPH, 39 /* speed */, Units::Metric},
+      {SpeedMacro::Speed40KmPH, 40 /* speed */, Units::Metric},
+      {SpeedMacro::Speed45KmPH, 45 /* speed */, Units::Metric},
+      {SpeedMacro::Speed50KmPH, 50 /* speed */, Units::Metric},
+      {SpeedMacro::Speed55KmPH, 55 /* speed */, Units::Metric},
+      {SpeedMacro::Speed56KmPH, 56 /* speed */, Units::Metric},
+      {SpeedMacro::Speed60KmPH, 60 /* speed */, Units::Metric},
+      {SpeedMacro::Speed64KmPH, 64 /* speed */, Units::Metric},
+      {SpeedMacro::Speed65KmPH, 65 /* speed */, Units::Metric},
+      {SpeedMacro::Speed70KmPH, 70 /* speed */, Units::Metric},
+      {SpeedMacro::Speed72KmPH, 72 /* speed */, Units::Metric},
+      {SpeedMacro::Speed75KmPH, 75 /* speed */, Units::Metric},
+      {SpeedMacro::Speed80KmPH, 80 /* speed */, Units::Metric},
+      {SpeedMacro::Speed82KmPH, 82 /* speed */, Units::Metric},
+      {SpeedMacro::Speed85KmPH, 85 /* speed */, Units::Metric},
+      {SpeedMacro::Speed89KmPH, 89 /* speed */, Units::Metric},
+      {SpeedMacro::Speed90KmPH, 90 /* speed */, Units::Metric},
+      {SpeedMacro::Speed93KmPH, 93 /* speed */, Units::Metric},
+      {SpeedMacro::Speed95KmPH, 95 /* speed */, Units::Metric},
+      {SpeedMacro::Speed96KmPH, 96 /* speed */, Units::Metric},
+      {SpeedMacro::Speed100KmPH, 100 /* speed */, Units::Metric},
+      {SpeedMacro::Speed104KmPH, 104 /* speed */, Units::Metric},
+      {SpeedMacro::Speed105KmPH, 105 /* speed */, Units::Metric},
+      {SpeedMacro::Speed106KmPH, 106 /* speed */, Units::Metric},
+      {SpeedMacro::Speed110KmPH, 110 /* speed */, Units::Metric},
+      {SpeedMacro::Speed112KmPH, 112 /* speed */, Units::Metric},
+      {SpeedMacro::Speed115KmPH, 115 /* speed */, Units::Metric},
+      {SpeedMacro::Speed120KmPH, 120 /* speed */, Units::Metric},
+      {SpeedMacro::Speed125KmPH, 125 /* speed */, Units::Metric},
+      {SpeedMacro::Speed127KmPH, 127 /* speed */, Units::Metric},
+      {SpeedMacro::Speed130KmPH, 130 /* speed */, Units::Metric},
+      {SpeedMacro::Speed135KmPH, 135 /* speed */, Units::Metric},
+      {SpeedMacro::Speed140KmPH, 140 /* speed */, Units::Metric},
+      {SpeedMacro::Speed141KmPH, 141 /* speed */, Units::Metric},
+      {SpeedMacro::Speed145KmPH, 145 /* speed */, Units::Metric},
+      {SpeedMacro::Speed150KmPH, 150 /* speed */, Units::Metric},
+      {SpeedMacro::Speed155KmPH, 155 /* speed */, Units::Metric},
+      {SpeedMacro::Speed160KmPH, 160 /* speed */, Units::Metric},
+      {SpeedMacro::Speed165KmPH, 165 /* speed */, Units::Metric},
+      {SpeedMacro::Speed170KmPH, 170 /* speed */, Units::Metric},
+      {SpeedMacro::Speed177KmPH, 177 /* speed */, Units::Metric},
+      {SpeedMacro::Speed180KmPH, 180 /* speed */, Units::Metric},
+      {SpeedMacro::Speed185KmPH, 185 /* speed */, Units::Metric},
+      {SpeedMacro::Speed190KmPH, 190 /* speed */, Units::Metric},
+      {SpeedMacro::Speed193KmPH, 193 /* speed */, Units::Metric},
+      {SpeedMacro::Speed195KmPH, 195 /* speed */, Units::Metric},
+      {SpeedMacro::Speed200KmPH, 200 /* speed */, Units::Metric},
+      {SpeedMacro::Speed201KmPH, 201 /* speed */, Units::Metric},
+      {SpeedMacro::Speed210KmPH, 210 /* speed */, Units::Metric},
+      {SpeedMacro::Speed217KmPH, 217 /* speed */, Units::Metric},
+      {SpeedMacro::Speed220KmPH, 220 /* speed */, Units::Metric},
+      {SpeedMacro::Speed230KmPH, 230 /* speed */, Units::Metric},
+      {SpeedMacro::Speed240KmPH, 240 /* speed */, Units::Metric},
+      {SpeedMacro::Speed250KmPH, 250 /* speed */, Units::Metric},
+      {SpeedMacro::Speed260KmPH, 260 /* speed */, Units::Metric},
+      {SpeedMacro::Speed270KmPH, 270 /* speed */, Units::Metric},
+      {SpeedMacro::Speed275KmPH, 275 /* speed */, Units::Metric},
+      {SpeedMacro::Speed280KmPH, 280 /* speed */, Units::Metric},
+      {SpeedMacro::Speed285KmPH, 285 /* speed */, Units::Metric},
+      {SpeedMacro::Speed300KmPH, 300 /* speed */, Units::Metric},
+      {SpeedMacro::Speed305KmPH, 305 /* speed */, Units::Metric},
+      {SpeedMacro::Speed310KmPH, 310 /* speed */, Units::Metric},
+      {SpeedMacro::Speed320KmPH, 320 /* speed */, Units::Metric},
+      {SpeedMacro::Speed350KmPH, 350 /* speed */, Units::Metric},
+      {SpeedMacro::Speed380KmPH, 380 /* speed */, Units::Metric},
 
-  // Mile per hours.
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed3mph)] = SpeedInUnits(3, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed4mph)] = SpeedInUnits(4, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed5mph)] = SpeedInUnits(5, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed6mph)] = SpeedInUnits(6, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed7mph)] = SpeedInUnits(7, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed8mph)] = SpeedInUnits(8, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed9mph)] = SpeedInUnits(9, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed10mph)] = SpeedInUnits(10, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed12mph)] = SpeedInUnits(12, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed13mph)] = SpeedInUnits(13, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed14mph)] = SpeedInUnits(14, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed15mph)] = SpeedInUnits(15, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed17mph)] = SpeedInUnits(17, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed18mph)] = SpeedInUnits(18, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed19mph)] = SpeedInUnits(19, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed20mph)] = SpeedInUnits(20, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed24mph)] = SpeedInUnits(24, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed25mph)] = SpeedInUnits(25, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed30mph)] = SpeedInUnits(30, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed35mph)] = SpeedInUnits(35, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed40mph)] = SpeedInUnits(40, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed45mph)] = SpeedInUnits(45, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed50mph)] = SpeedInUnits(50, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed55mph)] = SpeedInUnits(55, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed59mph)] = SpeedInUnits(59, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed60mph)] = SpeedInUnits(60, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed65mph)] = SpeedInUnits(65, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed70mph)] = SpeedInUnits(70, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed75mph)] = SpeedInUnits(75, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed79mph)] = SpeedInUnits(79, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed80mph)] = SpeedInUnits(80, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed85mph)] = SpeedInUnits(85, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed90mph)] = SpeedInUnits(90, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed95mph)] = SpeedInUnits(95, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed100mph)] = SpeedInUnits(100, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed105mph)] = SpeedInUnits(105, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed110mph)] = SpeedInUnits(110, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed115mph)] = SpeedInUnits(115, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed120mph)] = SpeedInUnits(120, Units::Imperial);
-  m_macroToSpeed[static_cast<uint8_t>(SpeedMacro::Speed125mph)] = SpeedInUnits(125, Units::Imperial);
+      // Miles per hour.
+      {SpeedMacro::Speed3MPH, 3 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed4MPH, 4 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed5MPH, 5 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed6MPH, 6 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed7MPH, 7 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed8MPH, 8 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed9MPH, 9 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed10MPH, 10 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed12MPH, 12 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed13MPH, 13 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed14MPH, 14 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed15MPH, 15 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed17MPH, 17 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed18MPH, 18 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed19MPH, 19 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed20MPH, 20 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed24MPH, 24 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed25MPH, 25 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed30MPH, 30 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed35MPH, 35 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed40MPH, 40 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed45MPH, 45 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed50MPH, 50 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed55MPH, 55 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed59MPH, 59 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed60MPH, 60 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed65MPH, 65 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed70MPH, 70 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed75MPH, 75 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed79MPH, 79 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed80MPH, 80 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed85MPH, 85 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed90MPH, 90 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed95MPH, 95 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed100MPH, 100 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed105MPH, 105 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed110MPH, 110 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed115MPH, 115 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed120MPH, 120 /* speed */, Units::Imperial},
+      {SpeedMacro::Speed125MPH, 125 /* speed */, Units::Imperial},
+  };
 
-  m_speedToMacro.insert(std::make_pair(SpeedInUnits(kInvalidSpeed, Units::Metric), SpeedMacro::Undefined));
-  for (size_t i = 1; i < std::numeric_limits<uint8_t>::max(); ++i)
+  for (auto const & e : table)
+    m_macroToSpeed[static_cast<uint8_t>(get<0>(e))] = SpeedInUnits(get<1>(e), get<2>(e));
+
+  CHECK_EQUAL(static_cast<uint8_t>(SpeedMacro::Undefined), 0, ());
+  m_speedToMacro.insert(make_pair(SpeedInUnits(kInvalidSpeed, Units::Metric), SpeedMacro::Undefined));
+  for (size_t i = 1; i < numeric_limits<uint8_t>::max(); ++i)
   {
     auto const & speed = m_macroToSpeed[i];
     if (!speed.IsValid())
       continue;
 
-    m_speedToMacro.insert(std::make_pair(speed, static_cast<SpeedMacro>(i)));
+    m_speedToMacro.insert(make_pair(speed, static_cast<SpeedMacro>(i)));
   }
 }
 
@@ -260,18 +279,30 @@ SpeedMacro MaxspeedConverter::SpeedToMacro(SpeedInUnits const & speed) const
 
 bool MaxspeedConverter::IsValidMacro(uint8_t macro) const
 {
+  CHECK_LESS(macro, numeric_limits<uint8_t>::max(), ());
   return m_macroToSpeed[macro].IsValid();
 }
 
-MaxspeedConverter const & GetMaxspeedConverter()
+// static
+MaxspeedConverter const & MaxspeedConverter::Instance()
 {
   static const MaxspeedConverter inst;
   return inst;
 }
 
+MaxspeedConverter const & GetMaxspeedConverter()
+{
+  return MaxspeedConverter::Instance();
+}
+
 bool HaveSameUnits(SpeedInUnits const & lhs, SpeedInUnits const & rhs)
 {
-  return lhs.m_units == rhs.m_units || !lhs.IsNumeric() || !rhs.IsNumeric();
+  return lhs.GetUnits() == rhs.GetUnits() || !lhs.IsNumeric() || !rhs.IsNumeric();
+}
+
+bool IsFeatureIdLess(FeatureMaxspeed const & lhs, FeatureMaxspeed const & rhs)
+{
+  return lhs.IsFeatureIdLess(rhs);
 }
 
 bool IsNumeric(uint16_t speed)
@@ -279,34 +310,34 @@ bool IsNumeric(uint16_t speed)
   return speed != kNoneMaxSpeed && speed != kWalkMaxSpeed && speed != kInvalidSpeed;
 }
 
-std::string DebugPrint(Maxspeed maxspeed)
+string DebugPrint(Maxspeed maxspeed)
 {
-  std::ostringstream oss;
-  oss << "Maxspeed [ m_units:" << DebugPrint(maxspeed.m_units)
-      << " m_forward:" << maxspeed.m_forward
-      << " m_backward:" << maxspeed.m_backward << " ]";
+  ostringstream oss;
+  oss << "Maxspeed [ m_units:" << DebugPrint(maxspeed.GetUnits())
+      << " m_forward:" << maxspeed.GetForward()
+      << " m_backward:" << maxspeed.GetBackward() << " ]";
   return oss.str();
 }
 
-std::string DebugPrint(SpeedMacro maxspeed)
+string DebugPrint(SpeedMacro maxspeed)
 {
-  std::ostringstream oss;
+  ostringstream oss;
   oss << "SpeedMacro:" << static_cast<int>(maxspeed) << " Decoded:"
       << DebugPrint(GetMaxspeedConverter().MacroToSpeed(maxspeed));
   return oss.str();
 }
 
-std::string DebugPrint(SpeedInUnits const & speed)
+string DebugPrint(SpeedInUnits const & speed)
 {
-  std::ostringstream oss;
-  oss << "SpeedInUnits [ m_speed == " << speed.m_speed
-      << ", m_units:" << DebugPrint(speed.m_units) << " ]";
+  ostringstream oss;
+  oss << "SpeedInUnits [ m_speed == " << speed.GetSpeed()
+      << ", m_units:" << DebugPrint(speed.GetUnits()) << " ]";
   return oss.str();
 }
 
-std::string DebugPrint(FeatureMaxspeed const & featureMaxspeed)
+string DebugPrint(FeatureMaxspeed const & featureMaxspeed)
 {
-  std::ostringstream oss;
+  ostringstream oss;
   oss << "FeatureMaxspeed [ m_featureId:" << featureMaxspeed.GetFeatureId()
       << " m_maxspeed:" << DebugPrint(featureMaxspeed.GetMaxspeed()) << " ]";
   return oss.str();
diff --git a/routing_common/maxspeed_conversion.hpp b/routing_common/maxspeed_conversion.hpp
index 0883b057b8..a54c1560dc 100644
--- a/routing_common/maxspeed_conversion.hpp
+++ b/routing_common/maxspeed_conversion.hpp
@@ -22,173 +22,186 @@ enum class SpeedMacro : uint8_t
   Walk,       // Driver should move as a walking person.
 
   // Km per hour.
-  Speed1kph = 10,
-  Speed2kph,
-  Speed3kph,
-  Speed4kph,
-  Speed5kph,
-  Speed6kph,
-  Speed7kph,
-  Speed8kph,
-  Speed9kph,
-  Speed10kph,
-  Speed11kph,
-  Speed12kph,
-  Speed13kph,
-  Speed14kph,
-  Speed15kph,
-  Speed16kph,
-  Speed18kph,
-  Speed20kph,
-  Speed22kph,
-  Speed25kph,
-  Speed24kph,
-  Speed28kph,
-  Speed30kph,
-  Speed32kph,
-  Speed35kph,
-  Speed36kph,
-  Speed39kph,
-  Speed40kph,
-  Speed45kph,
-  Speed50kph,
-  Speed55kph,
-  Speed56kph,
-  Speed60kph,
-  Speed64kph,
-  Speed65kph,
-  Speed70kph,
-  Speed72kph,
-  Speed75kph,
-  Speed80kph,
-  Speed82kph,
-  Speed85kph,
-  Speed89kph,
-  Speed90kph,
-  Speed93kph,
-  Speed95kph,
-  Speed96kph,
-  Speed100kph,
-  Speed104kph,
-  Speed105kph,
-  Speed106kph,
-  Speed110kph,
-  Speed112kph,
-  Speed115kph,
-  Speed120kph,
-  Speed125kph,
-  Speed127kph,
-  Speed130kph,
-  Speed135kph,
-  Speed140kph,
-  Speed141kph,
-  Speed145kph,
-  Speed150kph,
-  Speed155kph,
-  Speed160kph,
-  Speed165kph,
-  Speed170kph,
-  Speed177kph,
-  Speed180kph,
-  Speed185kph,
-  Speed190kph,
-  Speed193kph,
-  Speed195kph,
-  Speed200kph,
-  Speed201kph,
-  Speed210kph,
-  Speed217kph,
-  Speed220kph,
-  Speed230kph,
-  Speed240kph,
-  Speed250kph,
-  Speed260kph,
-  Speed270kph,
-  Speed275kph,
-  Speed280kph,
-  Speed285kph,
-  Speed300kph,
-  Speed305kph,
-  Speed310kph,
-  Speed320kph,
-  Speed350kph,
-  Speed380kph,
+  Speed1KmPH = 10,
+  Speed2KmPH,
+  Speed3KmPH,
+  Speed4KmPH,
+  Speed5KmPH,
+  Speed6KmPH,
+  Speed7KmPH,
+  Speed8KmPH,
+  Speed9KmPH,
+  Speed10KmPH,
+  Speed11KmPH,
+  Speed12KmPH,
+  Speed13KmPH,
+  Speed14KmPH,
+  Speed15KmPH,
+  Speed16KmPH,
+  Speed18KmPH,
+  Speed20KmPH,
+  Speed22KmPH,
+  Speed25KmPH,
+  Speed24KmPH,
+  Speed28KmPH,
+  Speed30KmPH,
+  Speed32KmPH,
+  Speed35KmPH,
+  Speed36KmPH,
+  Speed39KmPH,
+  Speed40KmPH,
+  Speed45KmPH,
+  Speed50KmPH,
+  Speed55KmPH,
+  Speed56KmPH,
+  Speed60KmPH,
+  Speed64KmPH,
+  Speed65KmPH,
+  Speed70KmPH,
+  Speed72KmPH,
+  Speed75KmPH,
+  Speed80KmPH,
+  Speed82KmPH,
+  Speed85KmPH,
+  Speed89KmPH,
+  Speed90KmPH,
+  Speed93KmPH,
+  Speed95KmPH,
+  Speed96KmPH,
+  Speed100KmPH,
+  Speed104KmPH,
+  Speed105KmPH,
+  Speed106KmPH,
+  Speed110KmPH,
+  Speed112KmPH,
+  Speed115KmPH,
+  Speed120KmPH,
+  Speed125KmPH,
+  Speed127KmPH,
+  Speed130KmPH,
+  Speed135KmPH,
+  Speed140KmPH,
+  Speed141KmPH,
+  Speed145KmPH,
+  Speed150KmPH,
+  Speed155KmPH,
+  Speed160KmPH,
+  Speed165KmPH,
+  Speed170KmPH,
+  Speed177KmPH,
+  Speed180KmPH,
+  Speed185KmPH,
+  Speed190KmPH,
+  Speed193KmPH,
+  Speed195KmPH,
+  Speed200KmPH,
+  Speed201KmPH,
+  Speed210KmPH,
+  Speed217KmPH,
+  Speed220KmPH,
+  Speed230KmPH,
+  Speed240KmPH,
+  Speed250KmPH,
+  Speed260KmPH,
+  Speed270KmPH,
+  Speed275KmPH,
+  Speed280KmPH,
+  Speed285KmPH,
+  Speed300KmPH,
+  Speed305KmPH,
+  Speed310KmPH,
+  Speed320KmPH,
+  Speed350KmPH,
+  Speed380KmPH,
 
-  // Mile per hours.
-  Speed3mph = 110,
-  Speed4mph,
-  Speed5mph,
-  Speed6mph,
-  Speed7mph,
-  Speed8mph,
-  Speed9mph,
-  Speed10mph,
-  Speed12mph,
-  Speed13mph,
-  Speed14mph,
-  Speed15mph,
-  Speed17mph,
-  Speed18mph,
-  Speed19mph,
-  Speed20mph,
-  Speed24mph,
-  Speed25mph,
-  Speed30mph,
-  Speed35mph,
-  Speed40mph,
-  Speed45mph,
-  Speed50mph,
-  Speed55mph,
-  Speed59mph,
-  Speed60mph,
-  Speed65mph,
-  Speed70mph,
-  Speed75mph,
-  Speed79mph,
-  Speed80mph,
-  Speed85mph,
-  Speed90mph,
-  Speed95mph,
-  Speed100mph,
-  Speed105mph,
-  Speed110mph,
-  Speed115mph,
-  Speed120mph,
-  Speed125mph,
+  // Miles per hour.
+  Speed3MPH = 110,
+  Speed4MPH,
+  Speed5MPH,
+  Speed6MPH,
+  Speed7MPH,
+  Speed8MPH,
+  Speed9MPH,
+  Speed10MPH,
+  Speed12MPH,
+  Speed13MPH,
+  Speed14MPH,
+  Speed15MPH,
+  Speed17MPH,
+  Speed18MPH,
+  Speed19MPH,
+  Speed20MPH,
+  Speed24MPH,
+  Speed25MPH,
+  Speed30MPH,
+  Speed35MPH,
+  Speed40MPH,
+  Speed45MPH,
+  Speed50MPH,
+  Speed55MPH,
+  Speed59MPH,
+  Speed60MPH,
+  Speed65MPH,
+  Speed70MPH,
+  Speed75MPH,
+  Speed79MPH,
+  Speed80MPH,
+  Speed85MPH,
+  Speed90MPH,
+  Speed95MPH,
+  Speed100MPH,
+  Speed105MPH,
+  Speed110MPH,
+  Speed115MPH,
+  Speed120MPH,
+  Speed125MPH,
 };
 
 uint16_t constexpr kInvalidSpeed = std::numeric_limits<uint16_t>::max();
 uint16_t constexpr kNoneMaxSpeed = std::numeric_limits<uint16_t>::max() - 1;
 uint16_t constexpr kWalkMaxSpeed = std::numeric_limits<uint16_t>::max() - 2;
 
-struct SpeedInUnits
+class SpeedInUnits
 {
+public:
   SpeedInUnits() = default;
   SpeedInUnits(uint16_t speed, measurement_utils::Units units) noexcept : m_speed(speed), m_units(units) {}
 
+  void SetSpeed(uint16_t speed) { m_speed = speed; }
+  void SetUnits(measurement_utils::Units units) { m_units = units; }
+
+  uint16_t GetSpeed() const { return m_speed; }
+  measurement_utils::Units GetUnits() const { return m_units; }
+
   bool operator==(SpeedInUnits const & rhs) const;
   bool operator<(SpeedInUnits const & rhs) const;
 
   bool IsNumeric() const;
   bool IsValid() const { return m_speed != kInvalidSpeed; }
 
+private:
   // Speed in km per hour or mile per hour depends on m_units value.
   uint16_t m_speed = kInvalidSpeed;
   // |m_units| is undefined in case of SpeedMacro::None and SpeedMacro::Walk.
   measurement_utils::Units m_units = measurement_utils::Units::Metric;
 };
 
-struct Maxspeed
+class Maxspeed
 {
-  measurement_utils::Units m_units = measurement_utils::Units::Metric;
-  // Speed in km per hour or mile per hour depends on |m_units|.
-  uint16_t m_forward = kInvalidSpeed;
-  // Speed in km per hour or mile per hour depends on |m_units|. If |m_backward| == kInvalidSpeed
-  // |m_forward| speed should be used for the both directions.
-  uint16_t m_backward = kInvalidSpeed;
+public:
+  Maxspeed() = default;
+  Maxspeed(measurement_utils::Units units, uint16_t forward, uint16_t backward);
 
   bool operator==(Maxspeed const & rhs) const;
 
+  void SetUnits(measurement_utils::Units units) { m_units = units; }
+  void SetForward(uint16_t forward) { m_forward = forward; }
+  void SetBackward(uint16_t backward) { m_backward = backward; }
+
+  measurement_utils::Units GetUnits() const { return m_units; }
+  uint16_t GetForward() const { return m_forward; }
+  uint16_t GetBackward() const { return m_backward; }
+
   bool IsValid() const { return m_forward != kInvalidSpeed; }
   /// \returns true if Maxspeed is considered as Bidirectional(). It means different
   /// speed is set for forward and backward direction. Otherwise returns false. It means
@@ -203,6 +216,14 @@ struct Maxspeed
   /// returned. Otherwise forward or backward speed in km per hour is returned. |kNoneMaxSpeed| and
   /// |kWalkMaxSpeed| are converted to some numbers.
   uint16_t GetSpeedKmPH(bool forward) const;
+
+private:
+  measurement_utils::Units m_units = measurement_utils::Units::Metric;
+  // Speed in km per hour or mile per hour depends on |m_units|.
+  uint16_t m_forward = kInvalidSpeed;
+  // Speed in km per hour or mile per hour depends on |m_units|. If |m_backward| == kInvalidSpeed
+  // |m_forward| speed should be used for the both directions.
+  uint16_t m_backward = kInvalidSpeed;
 };
 
 /// \brief Feature id and corresponding maxspeed tag value. |m_forward| and |m_backward| fields
@@ -216,9 +237,8 @@ public:
   FeatureMaxspeed(uint32_t fid, measurement_utils::Units units, uint16_t forward,
                   uint16_t backward = kInvalidSpeed) noexcept;
 
-  /// \note operator==() and operator<() do not correspond to each other.
   bool operator==(FeatureMaxspeed const & rhs) const;
-  bool operator<(FeatureMaxspeed const & rhs) const { return m_featureId < rhs.m_featureId; }
+  bool IsFeatureIdLess(FeatureMaxspeed const & rhs) const { return m_featureId < rhs.m_featureId; }
 
   bool IsValid() const { return m_maxspeed.IsValid(); }
   bool IsBidirectional() const { return m_maxspeed.IsBidirectional(); }
@@ -236,10 +256,7 @@ private:
 
 class MaxspeedConverter
 {
-  friend MaxspeedConverter const & GetMaxspeedConverter();
 public:
-  MaxspeedConverter();
-
   SpeedInUnits MacroToSpeed(SpeedMacro macro) const;
   SpeedMacro SpeedToMacro(SpeedInUnits const & speed) const;
 
@@ -248,13 +265,18 @@ public:
   /// in SpeedMacro enum class are considered as an invalid.
   bool IsValidMacro(uint8_t macro) const;
 
+  static MaxspeedConverter const & Instance();
+
 private:
+  MaxspeedConverter();
+
   std::array<SpeedInUnits, std::numeric_limits<uint8_t>::max()> m_macroToSpeed;
   std::map<SpeedInUnits, SpeedMacro> m_speedToMacro;
 };
 
 MaxspeedConverter const & GetMaxspeedConverter();
 bool HaveSameUnits(SpeedInUnits const & lhs, SpeedInUnits const & rhs);
+bool IsFeatureIdLess(FeatureMaxspeed const & lhs, FeatureMaxspeed const & rhs);
 
 /// \returns false if |speed| is equal to |kInvalidSpeed|, |kNoneMaxSpeed| or
 /// |kWalkMaxSpeed|.
diff --git a/routing_common/vehicle_model.hpp b/routing_common/vehicle_model.hpp
index 1995b7ba83..dc03e3f268 100644
--- a/routing_common/vehicle_model.hpp
+++ b/routing_common/vehicle_model.hpp
@@ -18,10 +18,13 @@ namespace feature { class TypesHolder; }
 
 namespace routing
 {
-/// \brief Params for calcualtion of an approximate speed on a feature.
+/// \brief Params for calculation of an approximate speed on a feature.
 struct SpeedParams
 {
-  SpeedParams() = delete;
+  SpeedParams(bool forward, bool inCity, Maxspeed maxspeed)
+    : m_forward(forward), m_inCity(inCity), m_maxspeed(maxspeed)
+  {
+  }
 
   bool m_forward;
   // |m_inCity| == true if a corresponding feature lies inside a city of a town.
diff --git a/xcode/routing/routing.xcodeproj/project.pbxproj b/xcode/routing/routing.xcodeproj/project.pbxproj
index 0388ffb661..f6d9f66e83 100644
--- a/xcode/routing/routing.xcodeproj/project.pbxproj
+++ b/xcode/routing/routing.xcodeproj/project.pbxproj
@@ -95,8 +95,6 @@
 		5631B662219B0F66009F47D4 /* maxspeed_tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5631B661219B0F66009F47D4 /* maxspeed_tests.cpp */; };
 		5631B66B219B125D009F47D4 /* maxspeeds.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5631B667219B125C009F47D4 /* maxspeeds.cpp */; };
 		5631B66C219B125D009F47D4 /* maxspeeds.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 5631B668219B125C009F47D4 /* maxspeeds.hpp */; };
-		5631B66D219B125D009F47D4 /* maxspeed_serialization.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5631B669219B125C009F47D4 /* maxspeed_serialization.cpp */; };
-		5631B66E219B125D009F47D4 /* maxspeed_serialization.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 5631B66A219B125D009F47D4 /* maxspeed_serialization.hpp */; };
 		56473D74214825B6007E6FBA /* city_roads_serialization.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 56473D72214825B4007E6FBA /* city_roads_serialization.hpp */; };
 		56555E561D897C90009D786D /* libalohalitics.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 6742ACE61C68A23B009CB89E /* libalohalitics.a */; };
 		56555E581D897C9D009D786D /* liboauthcpp.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 6742ACFA1C68A2D7009CB89E /* liboauthcpp.a */; };
@@ -168,6 +166,8 @@
 		56F0D75A1D896A5300045886 /* classificator.txt in Resources */ = {isa = PBXBuildFile; fileRef = 6742AD531C68BB14009CB89E /* classificator.txt */; };
 		56F0D75B1D896A5300045886 /* sound-strings in Resources */ = {isa = PBXBuildFile; fileRef = 6742AD611C68F747009CB89E /* sound-strings */; };
 		56FA20471FBF23A90045DE78 /* cross_mwm_ids.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 56FA20461FBF23A90045DE78 /* cross_mwm_ids.hpp */; };
+		56FEAA6E219E8A610073DF5F /* maxspeeds_serialization.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 56FEAA6C219E8A600073DF5F /* maxspeeds_serialization.hpp */; };
+		56FEAA6F219E8A610073DF5F /* maxspeeds_serialization.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 56FEAA6D219E8A610073DF5F /* maxspeeds_serialization.cpp */; };
 		670D049E1B0B4A970013A7AC /* nearest_edge_finder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 670D049C1B0B4A970013A7AC /* nearest_edge_finder.cpp */; };
 		670D049F1B0B4A970013A7AC /* nearest_edge_finder.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 670D049D1B0B4A970013A7AC /* nearest_edge_finder.hpp */; };
 		670EE55D1B6001E7001E8064 /* routing_session.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 670EE55A1B6001E7001E8064 /* routing_session.cpp */; };
@@ -384,8 +384,6 @@
 		5631B661219B0F66009F47D4 /* maxspeed_tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = maxspeed_tests.cpp; sourceTree = "<group>"; };
 		5631B667219B125C009F47D4 /* maxspeeds.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = maxspeeds.cpp; sourceTree = "<group>"; };
 		5631B668219B125C009F47D4 /* maxspeeds.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = maxspeeds.hpp; sourceTree = "<group>"; };
-		5631B669219B125C009F47D4 /* maxspeed_serialization.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = maxspeed_serialization.cpp; sourceTree = "<group>"; };
-		5631B66A219B125D009F47D4 /* maxspeed_serialization.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = maxspeed_serialization.hpp; sourceTree = "<group>"; };
 		56473D72214825B4007E6FBA /* city_roads_serialization.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = city_roads_serialization.hpp; sourceTree = "<group>"; };
 		5661A5CD20DE51C500C6B1D1 /* tools.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = tools.hpp; sourceTree = "<group>"; };
 		567059591F3AF96D0062672D /* checkpoint_predictor_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = checkpoint_predictor_test.cpp; sourceTree = "<group>"; };
@@ -426,6 +424,8 @@
 		56EE14DC1FE812FC0036F20C /* libtransit.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; path = libtransit.a; sourceTree = BUILT_PRODUCTS_DIR; };
 		56F0D75F1D896A5300045886 /* routing_benchmarks.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = routing_benchmarks.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		56FA20461FBF23A90045DE78 /* cross_mwm_ids.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = cross_mwm_ids.hpp; sourceTree = "<group>"; };
+		56FEAA6C219E8A600073DF5F /* maxspeeds_serialization.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = maxspeeds_serialization.hpp; sourceTree = "<group>"; };
+		56FEAA6D219E8A610073DF5F /* maxspeeds_serialization.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = maxspeeds_serialization.cpp; sourceTree = "<group>"; };
 		670D049C1B0B4A970013A7AC /* nearest_edge_finder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = nearest_edge_finder.cpp; sourceTree = "<group>"; };
 		670D049D1B0B4A970013A7AC /* nearest_edge_finder.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = nearest_edge_finder.hpp; sourceTree = "<group>"; };
 		670EE55A1B6001E7001E8064 /* routing_session.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = routing_session.cpp; sourceTree = "<group>"; };
@@ -802,8 +802,8 @@
 		675343FA1A3F640D00A0A8C3 /* routing */ = {
 			isa = PBXGroup;
 			children = (
-				5631B669219B125C009F47D4 /* maxspeed_serialization.cpp */,
-				5631B66A219B125D009F47D4 /* maxspeed_serialization.hpp */,
+				56FEAA6D219E8A610073DF5F /* maxspeeds_serialization.cpp */,
+				56FEAA6C219E8A600073DF5F /* maxspeeds_serialization.hpp */,
 				5631B667219B125C009F47D4 /* maxspeeds.cpp */,
 				5631B668219B125C009F47D4 /* maxspeeds.hpp */,
 				44AE4A10214FBB8D006321F5 /* speed_camera.cpp */,
@@ -965,7 +965,6 @@
 				67C79BA21E2CEE1400C40034 /* restriction_loader.hpp in Headers */,
 				674F9BCB1B0A580E00704FFA /* async_router.hpp in Headers */,
 				0C08AA391DF8329B004195DD /* routing_exceptions.hpp in Headers */,
-				5631B66E219B125D009F47D4 /* maxspeed_serialization.hpp in Headers */,
 				0C5BC9D21E28FD4E0071BFDD /* index_road_graph.hpp in Headers */,
 				674F9BD11B0A580E00704FFA /* online_cross_fetcher.hpp in Headers */,
 				0C470E701E0D4EB1005B824D /* segment.hpp in Headers */,
@@ -1034,6 +1033,7 @@
 				0C5FEC6B1DDE193F0017688C /* road_point.hpp in Headers */,
 				56099E2B1CC7C97D00A7772A /* turn_candidate.hpp in Headers */,
 				405F48DC1F6AD01C005BA81A /* routing_result.hpp in Headers */,
+				56FEAA6E219E8A610073DF5F /* maxspeeds_serialization.hpp in Headers */,
 				4065EA801F824A6C0094DEF3 /* transit_world_graph.hpp in Headers */,
 				56C4392D1E93E5DF00998E29 /* transition_points.hpp in Headers */,
 				44E5574A2136EEC900B01439 /* speed_camera_ser_des.hpp in Headers */,
@@ -1259,6 +1259,7 @@
 				0C5BC9D11E28FD4E0071BFDD /* index_road_graph.cpp in Sources */,
 				0C090C811E4E274000D52AFD /* index_graph_loader.cpp in Sources */,
 				349D1CE01E3F589900A878FD /* restrictions_serialization.cpp in Sources */,
+				56FEAA6F219E8A610073DF5F /* maxspeeds_serialization.cpp in Sources */,
 				5694CECC1EBA25F7004576D3 /* road_access.cpp in Sources */,
 				A1616E2B1B6B60AB003F078E /* router_delegate.cpp in Sources */,
 				6741AA9C1BF35331002C974C /* turns_notification_manager.cpp in Sources */,
@@ -1292,7 +1293,6 @@
 				0C81E1571F0258AA00DC66DF /* segmented_route.cpp in Sources */,
 				56CA09E51E30E73B00D05C9A /* index_graph_tools.cpp in Sources */,
 				0C0DF92A1DE898FF0055A22F /* routing_helpers.cpp in Sources */,
-				5631B66D219B125D009F47D4 /* maxspeed_serialization.cpp in Sources */,
 				67AB92E61B7B3E6E00AB5194 /* turns_tts_text.cpp in Sources */,
 				0C5FEC601DDE192A0017688C /* index_graph.cpp in Sources */,
 				0C5FEC6D1DDE19A40017688C /* index_graph_test.cpp in Sources */,