diff --git a/generator/generator_tests/intermediate_data_test.cpp b/generator/generator_tests/intermediate_data_test.cpp
index c906b79b58..60e480bce8 100644
--- a/generator/generator_tests/intermediate_data_test.cpp
+++ b/generator/generator_tests/intermediate_data_test.cpp
@@ -41,7 +41,7 @@ UNIT_TEST(Intermediate_Data_empty_way_element_save_load_test)
 
   e2.Read(r);
 
-  TEST_EQUAL(e2.nodes.size(), 0, ());
+  TEST_EQUAL(e2.m_nodes.size(), 0, ());
 }
 
 UNIT_TEST(Intermediate_Data_way_element_save_load_test)
@@ -50,7 +50,7 @@ UNIT_TEST(Intermediate_Data_way_element_save_load_test)
 
   WayElement e1(1 /* fake osm id */);
 
-  e1.nodes = testData;
+  e1.m_nodes = testData;
 
   using TBuffer = vector<uint8_t>;
   TBuffer buffer;
@@ -64,7 +64,7 @@ UNIT_TEST(Intermediate_Data_way_element_save_load_test)
 
   e2.Read(r);
 
-  TEST_EQUAL(e2.nodes, testData, ());
+  TEST_EQUAL(e2.m_nodes, testData, ());
 }
 
 UNIT_TEST(Intermediate_Data_relation_element_save_load_test)
@@ -76,13 +76,13 @@ UNIT_TEST(Intermediate_Data_relation_element_save_load_test)
 
   RelationElement e1;
 
-  e1.nodes = testData;
-  e1.ways = testData;
+  e1.m_nodes = testData;
+  e1.m_ways = testData;
 
-  e1.tags.emplace("key1", "value1");
-  e1.tags.emplace("key2", "value2");
-  e1.tags.emplace("key3", "value3");
-  e1.tags.emplace("key4", "value4");
+  e1.m_tags.emplace("key1", "value1");
+  e1.m_tags.emplace("key2", "value2");
+  e1.m_tags.emplace("key3", "value3");
+  e1.m_tags.emplace("key4", "value4");
 
   using TBuffer = vector<uint8_t>;
   TBuffer buffer;
@@ -94,24 +94,24 @@ UNIT_TEST(Intermediate_Data_relation_element_save_load_test)
 
   RelationElement e2;
 
-  e2.nodes.emplace_back(30, "000unknown");
-  e2.nodes.emplace_back(40, "000inner role");
-  e2.ways.emplace_back(10, "000inner");
-  e2.ways.emplace_back(20, "000outer");
-  e2.tags.emplace("key1old", "value1old");
-  e2.tags.emplace("key2old", "value2old");
+  e2.m_nodes.emplace_back(30, "000unknown");
+  e2.m_nodes.emplace_back(40, "000inner role");
+  e2.m_ways.emplace_back(10, "000inner");
+  e2.m_ways.emplace_back(20, "000outer");
+  e2.m_tags.emplace("key1old", "value1old");
+  e2.m_tags.emplace("key2old", "value2old");
 
   e2.Read(r);
 
-  TEST_EQUAL(e2.nodes, testData, ());
-  TEST_EQUAL(e2.ways, testData, ());
+  TEST_EQUAL(e2.m_nodes, testData, ());
+  TEST_EQUAL(e2.m_ways, testData, ());
 
-  TEST_EQUAL(e2.tags.size(), 4, ());
-  TEST_EQUAL(e2.tags["key1"], "value1", ());
-  TEST_EQUAL(e2.tags["key2"], "value2", ());
-  TEST_EQUAL(e2.tags["key3"], "value3", ());
-  TEST_EQUAL(e2.tags["key4"], "value4", ());
+  TEST_EQUAL(e2.m_tags.size(), 4, ());
+  TEST_EQUAL(e2.m_tags["key1"], "value1", ());
+  TEST_EQUAL(e2.m_tags["key2"], "value2", ());
+  TEST_EQUAL(e2.m_tags["key3"], "value3", ());
+  TEST_EQUAL(e2.m_tags["key4"], "value4", ());
 
-  TEST_NOT_EQUAL(e2.tags["key1old"], "value1old", ());
-  TEST_NOT_EQUAL(e2.tags["key2old"], "value2old", ());
+  TEST_NOT_EQUAL(e2.m_tags["key1old"], "value1old", ());
+  TEST_NOT_EQUAL(e2.m_tags["key2old"], "value2old", ());
 }
diff --git a/generator/generator_tests/restriction_collector_test.cpp b/generator/generator_tests/restriction_collector_test.cpp
index 55364c5f16..e955e48b8d 100644
--- a/generator/generator_tests/restriction_collector_test.cpp
+++ b/generator/generator_tests/restriction_collector_test.cpp
@@ -108,9 +108,9 @@ RelationElement MakeRelationElement(std::vector<RelationElement::Member> const &
                                     std::map<std::string, std::string> const & tags)
 {
   RelationElement r;
-  r.nodes = nodes;
-  r.ways = ways;
-  r.tags = tags;
+  r.m_nodes = nodes;
+  r.m_ways = ways;
+  r.m_tags = tags;
   return r;
 }
 
diff --git a/generator/intermediate_data.cpp b/generator/intermediate_data.cpp
index 657a507fe5..8255607e0c 100644
--- a/generator/intermediate_data.cpp
+++ b/generator/intermediate_data.cpp
@@ -398,8 +398,8 @@ void IntermediateDataWriter::AddRelation(Key id, RelationElement const & e)
     return;
 
   m_relations.Write(id, e);
-  AddToIndex(m_nodeToRelations, id, e.nodes);
-  AddToIndex(m_wayToRelations, id, e.ways);
+  AddToIndex(m_nodeToRelations, id, e.m_nodes);
+  AddToIndex(m_wayToRelations, id, e.m_ways);
 }
 
 void IntermediateDataWriter::SaveIndex()
diff --git a/generator/intermediate_elements.hpp b/generator/intermediate_elements.hpp
index 0beeb35419..9135b1a6db 100644
--- a/generator/intermediate_elements.hpp
+++ b/generator/intermediate_elements.hpp
@@ -17,44 +17,44 @@
 
 struct WayElement
 {
-  std::vector<uint64_t> nodes;
+  std::vector<uint64_t> m_nodes;
   uint64_t m_wayOsmId;
 
   explicit WayElement(uint64_t osmId) : m_wayOsmId(osmId) {}
 
-  bool IsValid() const { return !nodes.empty(); }
+  bool IsValid() const { return !m_nodes.empty(); }
 
   uint64_t GetOtherEndPoint(uint64_t id) const
   {
-    if (id == nodes.front())
-      return nodes.back();
+    if (id == m_nodes.front())
+      return m_nodes.back();
 
-    ASSERT(id == nodes.back(), ());
-    return nodes.front();
+    ASSERT(id == m_nodes.back(), ());
+    return m_nodes.front();
   }
 
   template <class ToDo>
   void ForEachPoint(ToDo & toDo) const
   {
-    std::for_each(nodes.begin(), nodes.end(), std::ref(toDo));
+    std::for_each(m_nodes.begin(), m_nodes.end(), std::ref(toDo));
   }
 
   template <class ToDo>
   void ForEachPointOrdered(uint64_t start, ToDo && toDo)
   {
-    ASSERT(!nodes.empty(), ());
-    if (start == nodes.front())
-      std::for_each(nodes.begin(), nodes.end(), std::ref(toDo));
+    ASSERT(!m_nodes.empty(), ());
+    if (start == m_nodes.front())
+      std::for_each(m_nodes.begin(), m_nodes.end(), std::ref(toDo));
     else
-      std::for_each(nodes.rbegin(), nodes.rend(), std::ref(toDo));
+      std::for_each(m_nodes.rbegin(), m_nodes.rend(), std::ref(toDo));
   }
 
   template <class TWriter>
   void Write(TWriter & writer) const
   {
-    uint64_t count = nodes.size();
+    uint64_t count = m_nodes.size();
     WriteVarUint(writer, count);
-    for (uint64_t e : nodes)
+    for (uint64_t e : m_nodes)
       WriteVarUint(writer, e);
   }
 
@@ -63,22 +63,22 @@ struct WayElement
   {
     ReaderSource<MemReader> r(reader);
     uint64_t count = ReadVarUint<uint64_t>(r);
-    nodes.resize(count);
-    for (uint64_t & e : nodes)
+    m_nodes.resize(count);
+    for (uint64_t & e : m_nodes)
       e = ReadVarUint<uint64_t>(r);
   }
 
   std::string ToString() const
   {
     std::stringstream ss;
-    ss << nodes.size() << " " << m_wayOsmId;
+    ss << m_nodes.size() << " " << m_wayOsmId;
     return ss.str();
   }
 
   std::string Dump() const
   {
     std::stringstream ss;
-    for (auto const & e : nodes)
+    for (auto const & e : m_nodes)
       ss << e << ";";
     return ss.str();
   }
@@ -89,50 +89,50 @@ class RelationElement
 public:
   using Member = std::pair<uint64_t, std::string>;
 
-  std::vector<Member> nodes;
-  std::vector<Member> ways;
-  std::map<std::string, std::string> tags;
+  std::vector<Member> m_nodes;
+  std::vector<Member> m_ways;
+  std::map<std::string, std::string> m_tags;
 
-  bool IsValid() const { return !(nodes.empty() && ways.empty()); }
+  bool IsValid() const { return !(m_nodes.empty() && m_ways.empty()); }
 
   std::string GetTagValue(std::string const & key) const
   {
-    auto it = tags.find(key);
-    return ((it != tags.end()) ? it->second : std::string());
+    auto it = m_tags.find(key);
+    return ((it != m_tags.end()) ? it->second : std::string());
   }
 
   std::string GetType() const { return GetTagValue("type"); }
-  bool FindWay(uint64_t id, std::string & role) const { return FindRoleImpl(ways, id, role); }
-  bool FindNode(uint64_t id, std::string & role) const { return FindRoleImpl(nodes, id, role); }
+  bool FindWay(uint64_t id, std::string & role) const { return FindRoleImpl(m_ways, id, role); }
+  bool FindNode(uint64_t id, std::string & role) const { return FindRoleImpl(m_nodes, id, role); }
 
   template <class ToDo>
   void ForEachWay(ToDo & toDo) const
   {
-    for (size_t i = 0; i < ways.size(); ++i)
-      toDo(ways[i].first, ways[i].second);
+    for (size_t i = 0; i < m_ways.size(); ++i)
+      toDo(m_ways[i].first, m_ways[i].second);
   }
 
   std::string GetNodeRole(uint64_t const id) const
   {
-    for (size_t i = 0; i < nodes.size(); ++i)
-      if (nodes[i].first == id)
-        return nodes[i].second;
+    for (size_t i = 0; i < m_nodes.size(); ++i)
+      if (m_nodes[i].first == id)
+        return m_nodes[i].second;
     return std::string();
   }
 
   std::string GetWayRole(uint64_t const id) const
   {
-    for (size_t i = 0; i < ways.size(); ++i)
-      if (ways[i].first == id)
-        return ways[i].second;
+    for (size_t i = 0; i < m_ways.size(); ++i)
+      if (m_ways[i].first == id)
+        return m_ways[i].second;
     return std::string();
   }
 
   void Swap(RelationElement & rhs)
   {
-    nodes.swap(rhs.nodes);
-    ways.swap(rhs.ways);
-    tags.swap(rhs.tags);
+    m_nodes.swap(rhs.m_nodes);
+    m_ways.swap(rhs.m_ways);
+    m_tags.swap(rhs.m_tags);
   }
 
   template <class TWriter>
@@ -160,12 +160,12 @@ public:
       }
     };
 
-    MembersWriter(nodes);
-    MembersWriter(ways);
+    MembersWriter(m_nodes);
+    MembersWriter(m_ways);
 
-    uint64_t count = tags.size();
+    uint64_t count = m_tags.size();
     WriteVarUint(writer, count);
-    for (auto const & e : tags)
+    for (auto const & e : m_tags)
     {
       // write key
       StringWriter(e.first);
@@ -200,11 +200,11 @@ public:
       }
     };
 
-    MembersReader(nodes);
-    MembersReader(ways);
+    MembersReader(m_nodes);
+    MembersReader(m_ways);
 
-    // decode tags
-    tags.clear();
+    // decode m_tags
+    m_tags.clear();
     uint64_t count = ReadVarUint<uint64_t>(r);
     for (uint64_t i = 0; i < count; ++i)
     {
@@ -213,25 +213,25 @@ public:
       StringReader(kv.first);
       // decode value
       StringReader(kv.second);
-      tags.emplace(kv);
+      m_tags.emplace(kv);
     }
   }
 
   std::string ToString() const
   {
     std::stringstream ss;
-    ss << nodes.size() << " " << ways.size() << " " << tags.size();
+    ss << m_nodes.size() << " " << m_ways.size() << " " << m_tags.size();
     return ss.str();
   }
 
   std::string Dump() const
   {
     std::stringstream ss;
-    for (auto const & e : nodes)
+    for (auto const & e : m_nodes)
       ss << "n{" << e.first << "," << e.second << "};";
-    for (auto const & e : ways)
+    for (auto const & e : m_ways)
       ss << "w{" << e.first << "," << e.second << "};";
-    for (auto const & e : tags)
+    for (auto const & e : m_tags)
       ss << "t{" << e.first << "," << e.second << "};";
     return ss.str();
   }
diff --git a/generator/osm_source.cpp b/generator/osm_source.cpp
index f79054265a..147dd3e0a5 100644
--- a/generator/osm_source.cpp
+++ b/generator/osm_source.cpp
@@ -66,7 +66,7 @@ void AddElementToCache(cache::IntermediateDataWriter & cache, OsmElement & eleme
     // Store way.
     WayElement way(element.m_id);
     for (uint64_t nd : element.Nodes())
-      way.nodes.push_back(nd);
+      way.m_nodes.push_back(nd);
 
     if (way.IsValid())
       cache.AddWay(element.m_id, way);
@@ -80,10 +80,10 @@ void AddElementToCache(cache::IntermediateDataWriter & cache, OsmElement & eleme
     {
       switch (member.m_type) {
       case OsmElement::EntityType::Node:
-        relation.nodes.emplace_back(member.m_ref, string(member.m_role));
+        relation.m_nodes.emplace_back(member.m_ref, string(member.m_role));
         break;
       case OsmElement::EntityType::Way:
-        relation.ways.emplace_back(member.m_ref, string(member.m_role));
+        relation.m_ways.emplace_back(member.m_ref, string(member.m_role));
         break;
       case OsmElement::EntityType::Relation:
         // we just ignore type == "relation"
@@ -94,7 +94,7 @@ void AddElementToCache(cache::IntermediateDataWriter & cache, OsmElement & eleme
     }
 
     for (auto const & tag : element.Tags())
-      relation.tags.emplace(tag.m_key, tag.m_value);
+      relation.m_tags.emplace(tag.m_key, tag.m_value);
 
     if (relation.IsValid())
       cache.AddRelation(element.m_id, relation);
diff --git a/generator/relation_tags.cpp b/generator/relation_tags.cpp
index 98d66a004b..a9ed22b969 100644
--- a/generator/relation_tags.cpp
+++ b/generator/relation_tags.cpp
@@ -40,7 +40,7 @@ void RelationTagsNode::Process(RelationElement const & e)
   bool const processAssociatedStreet = type == "associatedStreet" &&
                                        Base::IsKeyTagExists("addr:housenumber") &&
                                        !Base::IsKeyTagExists("addr:street");
-  for (auto const & p : e.tags)
+  for (auto const & p : e.m_tags)
   {
     // - used in railway station processing
     // - used in routing information
@@ -111,7 +111,7 @@ void RelationTagsWay::Process(RelationElement const & e)
                                        !Base::IsKeyTagExists("addr:street");
   bool const isHighway = Base::IsKeyTagExists("highway");
 
-  for (auto const & p : e.tags)
+  for (auto const & p : e.m_tags)
   {
     /// @todo Skip common key tags.
     if (p.first == "type" || p.first == "route" || p.first == "area")
diff --git a/generator/restriction_writer.cpp b/generator/restriction_writer.cpp
index b41ded1169..26878a1f7a 100644
--- a/generator/restriction_writer.cpp
+++ b/generator/restriction_writer.cpp
@@ -57,13 +57,13 @@ std::vector<RelationElement::Member> GetMembersByTag(RelationElement const & rel
                                                      std::string const & tag)
 {
   std::vector<RelationElement::Member> result;
-  for (auto const & member : relationElement.ways)
+  for (auto const & member : relationElement.m_ways)
   {
     if (member.second == tag)
       result.emplace_back(member);
   }
 
-  for (auto const & member : relationElement.nodes)
+  for (auto const & member : relationElement.m_nodes)
   {
     if (member.second == tag)
       result.emplace_back(member);
@@ -74,13 +74,13 @@ std::vector<RelationElement::Member> GetMembersByTag(RelationElement const & rel
 
 OsmElement::EntityType GetType(RelationElement const & relationElement, uint64_t osmId)
 {
-  for (auto const & member : relationElement.ways)
+  for (auto const & member : relationElement.m_ways)
   {
     if (member.first == osmId)
       return OsmElement::EntityType::Way;
   }
 
-  for (auto const & member : relationElement.nodes)
+  for (auto const & member : relationElement.m_nodes)
   {
     if (member.first == osmId)
       return OsmElement::EntityType::Node;
@@ -170,8 +170,8 @@ void RestrictionWriter::CollectRelation(RelationElement const & relationElement)
   uint64_t const toOsmId = to.back().first;
 
   // Extracting type of restriction.
-  auto const tagIt = relationElement.tags.find("restriction");
-  if (tagIt == relationElement.tags.end())
+  auto const tagIt = relationElement.m_tags.find("restriction");
+  if (tagIt == relationElement.m_tags.end())
     return;
 
   Restriction::Type type = Restriction::Type::No;
diff --git a/generator/ways_merger.cpp b/generator/ways_merger.cpp
index 3a4de9affe..c4d0306f0c 100644
--- a/generator/ways_merger.cpp
+++ b/generator/ways_merger.cpp
@@ -12,8 +12,8 @@ void AreaWayMerger::AddWay(uint64_t id)
   auto e = std::make_shared<WayElement>(id);
   if (m_cache->GetWay(id, *e) && e->IsValid())
   {
-    m_map.emplace(e->nodes.front(), e);
-    m_map.emplace(e->nodes.back(), e);
+    m_map.emplace(e->m_nodes.front(), e);
+    m_map.emplace(e->m_nodes.back(), e);
   }
 }
 }  // namespace generator