diff --git a/generator/road_access_generator.cpp b/generator/road_access_generator.cpp
index dfdcb9fc3f..b2dfd0cad2 100644
--- a/generator/road_access_generator.cpp
+++ b/generator/road_access_generator.cpp
@@ -124,11 +124,11 @@ bool ParseRoadAccess(string const & roadAccessPath, map<osm::Id, uint32_t> const
     uint32_t const numSegments = static_cast<uint32_t>(ft.GetPointsCount() - 1);
 
     // Set this road access type for the entire feature.
-    for (uint32_t segmentId = 0; segmentId < numSegments; ++segmentId)
+    for (uint32_t segmentIdx = 0; segmentIdx < numSegments; ++segmentIdx)
     {
-      addSegment(Segment(kFakeNumMwmId, featureId, segmentId, true /* isForward */), routerType,
+      addSegment(Segment(kFakeNumMwmId, featureId, segmentIdx, true /* isForward */), routerType,
                  roadAccessType, osmId);
-      addSegment(Segment(kFakeNumMwmId, featureId, segmentId, false /* isForward */), routerType,
+      addSegment(Segment(kFakeNumMwmId, featureId, segmentIdx, false /* isForward */), routerType,
                  roadAccessType, osmId);
     }
   }
diff --git a/generator/road_access_generator.hpp b/generator/road_access_generator.hpp
index 0c54a33541..4e0f457fb9 100644
--- a/generator/road_access_generator.hpp
+++ b/generator/road_access_generator.hpp
@@ -24,7 +24,7 @@ class RoadAccessTagProcessor
 public:
   using TagMapping = map<OsmElement::Tag, RoadAccess::Type>;
 
-  RoadAccessTagProcessor(RouterType routerType);
+  explicit RoadAccessTagProcessor(RouterType routerType);
 
   void Process(OsmElement const & elem, std::ofstream & oss) const;
 
diff --git a/routing/road_access.cpp b/routing/road_access.cpp
index 5c0796c2ed..034f273583 100644
--- a/routing/road_access.cpp
+++ b/routing/road_access.cpp
@@ -7,14 +7,10 @@ using namespace std;
 
 namespace
 {
-string const kNo = "No";
-string const kPrivate = "Private";
-string const kDestination = "Destination";
-string const kYes = "Yes";
-string const kCount = "Count";
-string const kNames[] = {kNo, kPrivate, kDestination, kYes, kCount};
+string const kNames[] = {"No", "Private", "Destination", "Yes", "Count"};
 
 // *NOTE* Order may be important for users (such as serializers).
+// Add new types to the end of the list.
 vector<routing::RouterType> const kSupportedRouterTypes = {
   routing::RouterType::Vehicle,
   routing::RouterType::Pedestrian,
@@ -79,8 +75,8 @@ string ToString(RoadAccess::Type type)
 {
   if (type <= RoadAccess::Type::Count)
     return kNames[static_cast<size_t>(type)];
-  ASSERT(false, ("Bad road access type"));
-  return {};
+  ASSERT(false, ("Bad road access type", static_cast<size_t>(type)));
+  return "Bad RoadAccess::Type";
 }
 
 void FromString(string const & s, RoadAccess::Type & result)
@@ -93,6 +89,7 @@ void FromString(string const & s, RoadAccess::Type & result)
       return;
     }
   }
+  result = RoadAccess::Type::Count;
   ASSERT(false, ("Could not read RoadAccess from the string", s));
 }
 
diff --git a/routing/road_access_serialization.hpp b/routing/road_access_serialization.hpp
index 271ea8016a..61c3e84fa2 100644
--- a/routing/road_access_serialization.hpp
+++ b/routing/road_access_serialization.hpp
@@ -1,17 +1,16 @@
 #pragma once
 
+#include "routing/coding.hpp"
 #include "routing/num_mwm_id.hpp"
 #include "routing/road_access.hpp"
 #include "routing/segment.hpp"
 
 #include "coding/bit_streams.hpp"
-#include "coding/elias_coder.hpp"
 #include "coding/reader.hpp"
 #include "coding/varint.hpp"
 #include "coding/write_to_sink.hpp"
 
 #include "base/assert.hpp"
-#include "base/checked_cast.hpp"
 
 #include <algorithm>
 #include <array>
@@ -83,11 +82,11 @@ private:
 
   // todo(@m) This code borrows heavily from traffic/traffic_info.hpp:SerializeTrafficKeys.
   template <typename Sink>
-  static void SerializeSegments(Sink & sink, vector<Segment> const & segments)
+  static void SerializeSegments(Sink & sink, std::vector<Segment> const & segments)
   {
-    vector<uint32_t> featureIds(segments.size());
-    vector<uint32_t> segmentIndices(segments.size());
-    vector<bool> isForward(segments.size());
+    std::vector<uint32_t> featureIds(segments.size());
+    std::vector<uint32_t> segmentIndices(segments.size());
+    std::vector<bool> isForward(segments.size());
 
     for (size_t i = 0; i < segments.size(); ++i)
     {
@@ -105,48 +104,42 @@ private:
       BitWriter<Sink> bitWriter(sink);
 
       uint32_t prevFid = 0;
-      for (auto const & fid : featureIds)
+      for (auto const fid : featureIds)
       {
         CHECK_GREATER_OR_EQUAL(fid, prevFid, ());
         uint64_t const fidDiff = static_cast<uint64_t>(fid - prevFid);
-        bool ok = coding::GammaCoder::Encode(bitWriter, fidDiff + 1);
-        ASSERT(ok, ());
-        UNUSED_VALUE(ok);
+        WriteGamma(bitWriter, fidDiff + 1);
         prevFid = fid;
       }
 
-      for (auto const & s : segmentIndices)
-      {
-        bool ok = coding::GammaCoder::Encode(bitWriter, s + 1);
-        ASSERT(ok, ());
-        UNUSED_VALUE(ok);
-      }
+      for (auto const idx : segmentIndices)
+        WriteGamma(bitWriter, idx + 1);
 
-      for (auto const & val : isForward)
+      for (auto const val : isForward)
         bitWriter.Write(val ? 1 : 0, 1 /* numBits */);
     }
   }
 
   template <typename Source>
-  static void DeserializeSegments(Source & src, vector<Segment> & segments)
+  static void DeserializeSegments(Source & src, std::vector<Segment> & segments)
   {
     auto const n = static_cast<size_t>(ReadVarUint<uint64_t>(src));
 
-    vector<uint32_t> featureIds(n);
-    vector<size_t> segmentIndices(n);
-    vector<bool> isForward(n);
+    std::vector<uint32_t> featureIds(n);
+    std::vector<uint32_t> segmentIndices(n);
+    std::vector<bool> isForward(n);
 
     {
-      BitReader<decltype(src)> bitReader(src);
+      BitReader<Source> bitReader(src);
       uint32_t prevFid = 0;
       for (size_t i = 0; i < n; ++i)
       {
-        prevFid += coding::GammaCoder::Decode(bitReader) - 1;
+        prevFid += ReadGamma<uint64_t>(bitReader) - 1;
         featureIds[i] = prevFid;
       }
 
       for (size_t i = 0; i < n; ++i)
-        segmentIndices[i] = coding::GammaCoder::Decode(bitReader) - 1;
+        segmentIndices[i] = ReadGamma<uint32_t>(bitReader) - 1;
 
       for (size_t i = 0; i < n; ++i)
         isForward[i] = bitReader.Read(1) > 0;
diff --git a/routing/routing_tests/road_access_test.cpp b/routing/routing_tests/road_access_test.cpp
index fc294e3c5e..66f8552f66 100644
--- a/routing/routing_tests/road_access_test.cpp
+++ b/routing/routing_tests/road_access_test.cpp
@@ -21,7 +21,8 @@ namespace
 UNIT_TEST(RoadAccess_Serialization)
 {
   map<Segment, RoadAccess::Type> const m0 = {
-      {Segment(kFakeNumMwmId, 1, 0, false), RoadAccess::Type::No},
+      {Segment(kFakeNumMwmId, 1 /* feature id */, 0 /* segment idx */, false /* forward */),
+       RoadAccess::Type::No},
       {Segment(kFakeNumMwmId, 2, 2, false), RoadAccess::Type::Private},
   };
 
@@ -31,8 +32,8 @@ UNIT_TEST(RoadAccess_Serialization)
   };
 
   RoadAccess roadAccess;
-  roadAccess.SetTypes(static_cast<RouterType>(0), m0);
-  roadAccess.SetTypes(static_cast<RouterType>(1), m1);
+  roadAccess.SetTypes(RouterType::Vehicle, m0);
+  roadAccess.SetTypes(RouterType::Pedestrian, m1);
 
   vector<uint8_t> buf;
   {