diff --git a/base/base_tests/cache_test.cpp b/base/base_tests/cache_test.cpp
index 2644f8ddf7..0073c65e59 100644
--- a/base/base_tests/cache_test.cpp
+++ b/base/base_tests/cache_test.cpp
@@ -164,7 +164,7 @@ UNIT_TEST(CacheSmoke_6)
 UNIT_TEST(Cache_Init)
 {
   my::Cache<uint32_t, char> cache;
-  cache.Init(3);
+  cache.Init(3 /* logCacheSize */);
 
   bool found = true;
   cache.Find(5, found) = 'a';
@@ -173,7 +173,7 @@ UNIT_TEST(Cache_Init)
   TEST_EQUAL(cache.Find(5, found), 'a', ());
   TEST(found, ());
 
-  cache.Init(1);
+  cache.Init(1 /* logCacheSize */);
   cache.Find(5, found) = 'b';
   TEST(!found, ());
 
diff --git a/base/cache.hpp b/base/cache.hpp
index 8d81105690..9b50f14e25 100644
--- a/base/cache.hpp
+++ b/base/cache.hpp
@@ -3,6 +3,7 @@
 #include "base/macros.hpp"
 
 #include "std/type_traits.hpp"
+#include "std/unique_ptr.hpp"
 #include "std/utility.hpp"
 
 
@@ -14,42 +15,29 @@ namespace my
     DISALLOW_COPY(Cache);
 
   public:
-    Cache() : m_Cache(nullptr) {}
+    Cache() = default;
+    Cache(Cache && r) = default;
 
-    // @logCacheSize is pow of two for number of elements in cache.
     explicit Cache(uint32_t logCacheSize)
     {
       Init(logCacheSize);
     }
 
-    Cache(Cache && r) : m_Cache(r.m_Cache), m_HashMask(r.m_HashMask)
-    {
-      r.m_Cache = nullptr;
-    }
-
+    /// @param[in] logCacheSize is pow of two for number of elements in cache.
     void Init(uint32_t logCacheSize)
     {
+      ASSERT(logCacheSize > 0 && logCacheSize < 32, (logCacheSize));
       static_assert((is_same<KeyT, uint32_t>::value || is_same<KeyT, uint64_t>::value), "");
 
-      m_Cache = new Data[1 << logCacheSize];
-      m_HashMask = (1 << logCacheSize) - 1;
-
-      // We always use cache with static constant. So debug assert is enough here.
-      ASSERT_GREATER(logCacheSize, 0, ());
-      ASSERT_GREATER(m_HashMask, 0, ());
-      ASSERT_LESS(logCacheSize, 32, ());
+      m_cache.reset(new Data[1 << logCacheSize]);
+      m_hashMask = (1 << logCacheSize) - 1;
 
       Reset();
     }
 
-    ~Cache()
-    {
-      delete [] m_Cache;
-    }
-
     uint32_t GetCacheSize() const
     {
-      return m_HashMask + 1;
+      return m_hashMask + 1;
     }
 
     // Find value by @key. If @key is found, returns reference to its value.
@@ -58,7 +46,7 @@ namespace my
     // TODO: Return pair<ValueT *, bool> instead?
     ValueT & Find(KeyT const & key, bool & found)
     {
-      Data & data = m_Cache[Index(key)];
+      Data & data = m_cache[Index(key)];
       if (data.m_Key == key)
       {
         found = true;
@@ -74,16 +62,16 @@ namespace my
     template <typename F>
     void ForEachValue(F && f)
     {
-      for (uint32_t i = 0; i <= m_HashMask; ++i)
-        f(m_Cache[i].m_Value);
+      for (uint32_t i = 0; i <= m_hashMask; ++i)
+        f(m_cache[i].m_Value);
     }
 
     void Reset()
     {
       // Initialize m_Cache such, that Index(m_Cache[i].m_Key) != i.
-      for (uint32_t i = 0; i <= m_HashMask; ++i)
+      for (uint32_t i = 0; i <= m_hashMask; ++i)
       {
-        KeyT & key = m_Cache[i].m_Key;
+        KeyT & key = m_cache[i].m_Key;
         for (key = 0; Index(key) == i; ++key) ;
       }
     }
@@ -91,7 +79,7 @@ namespace my
   private:
     inline size_t Index(KeyT const & key) const
     {
-      return static_cast<size_t>(Hash(key) & m_HashMask);
+      return static_cast<size_t>(Hash(key) & m_hashMask);
     }
 
     inline static uint32_t Hash(uint32_t x)
@@ -116,8 +104,8 @@ namespace my
       ValueT m_Value;
     };
 
-    Data * m_Cache;
-    uint32_t m_HashMask;
+    unique_ptr<Data[]> m_cache;
+    uint32_t m_hashMask;
   };
 
   // Simple cache that stores list of values and provides cache missing statistics.
@@ -127,14 +115,13 @@ namespace my
   {
   public:
     CacheWithStat() = default;
-    CacheWithStat(CacheWithStat && r) = default;
 
-    // @logCacheSize is pow of two for number of elements in cache.
     explicit CacheWithStat(uint32_t logCacheSize)
       : m_cache(logCacheSize), m_miss(0), m_access(0)
     {
     }
 
+    /// @param[in] logCacheSize is pow of two for number of elements in cache.
     void Init(uint32_t logCacheSize)
     {
       m_cache.Init(logCacheSize);
diff --git a/defines.hpp b/defines.hpp
index 7eded22a62..9058753286 100644
--- a/defines.hpp
+++ b/defines.hpp
@@ -5,6 +5,7 @@
 #define FONT_FILE_EXTENSION ".ttf"
 #define OSM2FEATURE_FILE_EXTENSION ".osm2ft"
 #define EXTENSION_TMP ".tmp"
+#define ADDR_FILE_EXTENSION ".addr"
 
 #define DATA_FILE_TAG "dat"
 #define GEOMETRY_FILE_TAG "geom"
diff --git a/generator/feature_sorter.cpp b/generator/feature_sorter.cpp
index 076e7f4ccb..9d62a2765d 100644
--- a/generator/feature_sorter.cpp
+++ b/generator/feature_sorter.cpp
@@ -539,8 +539,8 @@ namespace feature
 
   bool GenerateFinalFeatures(feature::GenerateInfo const & info, string const & name, int mapType)
   {
-    string const srcFilePath = info.GetTmpFile(name);
-    string const datFilePath = info.GetTargetFile(name);
+    string const srcFilePath = info.GetTmpFileName(name);
+    string const datFilePath = info.GetTargetFileName(name);
 
     // stores cellIds for middle points
     CalculateMidPoints midPoints;
diff --git a/generator/generate_info.hpp b/generator/generate_info.hpp
index 0a00d45c57..f9d01f0e8f 100644
--- a/generator/generate_info.hpp
+++ b/generator/generate_info.hpp
@@ -16,17 +16,21 @@ struct GenerateInfo
   {
   }
 
-  string GetTmpFile(string const & fileName, char const * ext = DATA_FILE_EXTENSION_TMP) const
+  string GetTmpFileName(string const & fileName, char const * ext = DATA_FILE_EXTENSION_TMP) const
   {
     return (m_tmpDir + fileName + ext);
   }
-  string GetTargetFile(string const & fileName, char const * ext = DATA_FILE_EXTENSION) const
+  string GetTargetFileName(string const & fileName, char const * ext = DATA_FILE_EXTENSION) const
   {
     return (m_targetDir + fileName + ext);
   }
-  string GetAddressesFile() const
+  string GetIntermediateFileName(string const & fileName, char const * ext = DATA_FILE_EXTENSION) const
   {
-    return ((m_genAddresses && !m_fileName.empty()) ? GetTargetFile(m_fileName, ".addr") : string());
+    return (m_intermediateDir + fileName + ext);
+  }
+  string GetAddressesFileName() const
+  {
+    return ((m_genAddresses && !m_fileName.empty()) ? GetTargetFileName(m_fileName, ADDR_FILE_EXTENSION) : string());
   }
 
   // Directory for .mwm.tmp files.
diff --git a/generator/osm_source.cpp b/generator/osm_source.cpp
index cdbc275a79..03b4be5ae0 100644
--- a/generator/osm_source.cpp
+++ b/generator/osm_source.cpp
@@ -224,8 +224,7 @@ namespace
       for (size_t i = 0; i < ARRAY_SIZE(arr); ++i)
         m_types[i] = c.GetTypeByPath(vector<string>(arr[i], arr[i] + 2));
 
-      m_srcCoastsFile = info.m_intermediateDir + WORLD_COASTS_FILE_NAME + ".geom";
-      string const srcCoastsFileDump = info.m_intermediateDir + WORLD_COASTS_FILE_NAME + ".rawdump";
+      m_srcCoastsFile = info.GetIntermediateFileName(WORLD_COASTS_FILE_NAME, ".geom");
 
       CHECK(!info.m_makeCoasts || !info.m_createWorld,
             ("We can't do make_coasts and generate_world at the same time"));
@@ -236,7 +235,7 @@ namespace
 
         if (info.m_emitCoasts)
         {
-          m_coastsHolder.reset(new feature::FeaturesCollector(info.GetTmpFile(WORLD_COASTS_FILE_NAME)));
+          m_coastsHolder.reset(new feature::FeaturesCollector(info.GetTmpFileName(WORLD_COASTS_FILE_NAME)));
         }
       }
       else
@@ -245,7 +244,8 @@ namespace
         // 20000 - max points count per feature
         m_coasts.reset(new CoastlineFeaturesGenerator(Type(NATURAL_COASTLINE), 4, 10, 20000));
 
-        m_coastsHolder.reset(new feature::FeaturesAndRawGeometryCollector(m_srcCoastsFile, srcCoastsFileDump));
+        m_coastsHolder.reset(new feature::FeaturesAndRawGeometryCollector(
+                               m_srcCoastsFile, info.GetIntermediateFileName(WORLD_COASTS_FILE_NAME, ".rawdump")));
       }
 
       if (info.m_createWorld)
@@ -494,7 +494,7 @@ bool GenerateFeaturesImpl(feature::GenerateInfo & info, string const &osmFileTyp
     SecondPassParser<MainFeaturesEmitter, HolderT> parser(
                   bucketer, holder,
                   info.m_makeCoasts ? classif().GetCoastType() : 0,
-                  info.GetAddressesFile());
+                  info.GetAddressesFileName());
 
     SourceReader reader(osmFileName);
 
diff --git a/generator/polygonizer.hpp b/generator/polygonizer.hpp
index 7e75f153d7..b69b0e8149 100644
--- a/generator/polygonizer.hpp
+++ b/generator/polygonizer.hpp
@@ -151,7 +151,7 @@ namespace feature
       if (country->m_index == -1)
       {
         m_Names.push_back(country->m_name);
-        m_Buckets.push_back(new FeatureOutT(m_info.GetTmpFile(country->m_name)));
+        m_Buckets.push_back(new FeatureOutT(m_info.GetTmpFileName(country->m_name)));
         country->m_index = m_Buckets.size()-1;
       }
 
diff --git a/generator/world_map_generator.hpp b/generator/world_map_generator.hpp
index cbc909869d..51f288b393 100644
--- a/generator/world_map_generator.hpp
+++ b/generator/world_map_generator.hpp
@@ -22,9 +22,9 @@ class WorldMapGenerator
 
   public:
     explicit EmitterImpl(feature::GenerateInfo const & info)
-      : m_output(info.GetTmpFile(WORLD_FILE_NAME))
+      : m_output(info.GetTmpFileName(WORLD_FILE_NAME))
     {
-      LOG(LINFO, ("Output World file:", info.GetTmpFile(WORLD_FILE_NAME)));
+      LOG(LINFO, ("Output World file:", info.GetTmpFileName(WORLD_FILE_NAME)));
     }
 
     /// This function is called after merging linear features.
diff --git a/graphics/overlay_element.hpp b/graphics/overlay_element.hpp
index 6dcc4c4b56..4c6c0441f1 100644
--- a/graphics/overlay_element.hpp
+++ b/graphics/overlay_element.hpp
@@ -3,7 +3,7 @@
 #include "graphics/defines.hpp"
 #include "graphics/color.hpp"
 
-#include "indexer/mwm_set.hpp"
+#include "indexer/feature_decl.hpp"
 
 #include "geometry/point2d.hpp"
 #include "geometry/any_rect2d.hpp"
@@ -23,21 +23,19 @@ namespace graphics
   public:
     struct UserInfo
     {
-      MwmSet::MwmId m_mwmID;
-      uint32_t m_fID;
+      FeatureID m_featureID;
 
-      UserInfo() : m_fID(0) {}
-      inline bool IsValid() const { return m_mwmID.IsAlive(); }
-      inline bool operator== (UserInfo const & a) const
+      inline bool IsValid() const { return m_featureID.IsValid(); }
+      inline bool operator== (UserInfo const & r) const
       {
-        return IsValid() && (a.m_mwmID == m_mwmID) && (a.m_fID == m_fID);
+        return (IsValid() && m_featureID == r.m_featureID);
       }
     };
 
   private:
     m2::PointD m_pivot;
     graphics::EPosition m_position;
-    double m_depth;    
+    double m_depth;
 
     enum { NEED_REDRAW,
            FROZEN,
diff --git a/indexer/feature_decl.cpp b/indexer/feature_decl.cpp
index e3df79d2f6..c697f6948c 100644
--- a/indexer/feature_decl.cpp
+++ b/indexer/feature_decl.cpp
@@ -6,6 +6,6 @@
 string DebugPrint(FeatureID const & id)
 {
   ostringstream ss;
-  ss << "{ " << DebugPrint(id.m_mwmId) << ", " << id.m_ind << " }";
+  ss << "{ " << DebugPrint(id.m_mwmId) << ", " << id.m_index << " }";
   return ss.str();
 }
diff --git a/indexer/feature_decl.hpp b/indexer/feature_decl.hpp
index b0f706fa7d..6c89648b5f 100644
--- a/indexer/feature_decl.hpp
+++ b/indexer/feature_decl.hpp
@@ -20,24 +20,24 @@ enum EGeomType
 struct FeatureID
 {
   MwmSet::MwmId m_mwmId;
-  uint32_t m_ind;
+  uint32_t m_index;
 
-  FeatureID() : m_ind(0) {}
-  FeatureID(MwmSet::MwmId const & mwmId, uint32_t ind) : m_mwmId(mwmId), m_ind(ind) {}
+  FeatureID() : m_index(0) {}
+  FeatureID(MwmSet::MwmId const & mwmId, uint32_t index) : m_mwmId(mwmId), m_index(index) {}
 
   bool IsValid() const { return m_mwmId.IsAlive(); }
 
   inline bool operator<(FeatureID const & r) const
   {
     if (m_mwmId == r.m_mwmId)
-      return m_ind < r.m_ind;
+      return m_index < r.m_index;
     else
       return m_mwmId < r.m_mwmId;
   }
 
   inline bool operator==(FeatureID const & r) const
   {
-    return (m_mwmId == r.m_mwmId && m_ind == r.m_ind);
+    return (m_mwmId == r.m_mwmId && m_index == r.m_index);
   }
 
   inline bool operator!=(FeatureID const & r) const { return !(*this == r); }
diff --git a/indexer/feature_loader.cpp b/indexer/feature_loader.cpp
index 85e03bb9d9..0e79af92bd 100644
--- a/indexer/feature_loader.cpp
+++ b/indexer/feature_loader.cpp
@@ -260,11 +260,11 @@ void LoaderCurrent::ParseMetadata()
     DDVector<IdxElementT, FilesContainerR::ReaderT> idx(m_Info.GetMetadataIndexReader());
     
     auto it = lower_bound(idx.begin(), idx.end()
-                          , make_pair(uint32_t(m_pF->m_id.m_ind), uint32_t(0))
+                          , make_pair(uint32_t(m_pF->m_id.m_index), uint32_t(0))
                           , [](IdxElementT const & v1, IdxElementT const & v2) { return v1.first < v2.first; }
                           );
 
-    if (it != idx.end() && m_pF->m_id.m_ind == it->first)
+    if (it != idx.end() && m_pF->m_id.m_index == it->first)
     {
       ReaderSource<FilesContainerR::ReaderT> reader(m_Info.GetMetadataReader());
       reader.Skip(it->second);
diff --git a/indexer/features_vector.cpp b/indexer/features_vector.cpp
index 32bdab3adc..e1329cc85c 100644
--- a/indexer/features_vector.cpp
+++ b/indexer/features_vector.cpp
@@ -6,10 +6,11 @@
 #include "platform/constants.hpp"
 
 
-void FeaturesVector::GetByIndex(uint32_t ind, FeatureType & ft) const
+void FeaturesVector::GetByIndex(uint32_t index, FeatureType & ft) const
 {
   uint32_t offset = 0, size = 0;
-  m_RecordReader.ReadRecord(m_table ? m_table->GetFeatureOffset(ind) : ind, m_buffer, offset, size);
+  auto const ftOffset = m_table ? m_table->GetFeatureOffset(index) : index;
+  m_RecordReader.ReadRecord(ftOffset, m_buffer, offset, size);
   ft.Deserialize(m_LoadInfo.GetLoader(), &m_buffer[offset]);
 }
 
diff --git a/indexer/features_vector.hpp b/indexer/features_vector.hpp
index 3c63fc3833..53d8c46d66 100644
--- a/indexer/features_vector.hpp
+++ b/indexer/features_vector.hpp
@@ -20,20 +20,20 @@ public:
   {
   }
 
-  void GetByIndex(uint32_t ind, FeatureType & ft) const;
+  void GetByIndex(uint32_t index, FeatureType & ft) const;
 
-  template <class ToDo> void ForEach(ToDo toDo) const
+  template <class ToDo> void ForEach(ToDo && toDo) const
   {
-    uint32_t ind = 0;
+    uint32_t index = 0;
     m_RecordReader.ForEachRecord([&] (uint32_t pos, char const * data, uint32_t /*size*/)
     {
       FeatureType ft;
       ft.Deserialize(m_LoadInfo.GetLoader(), data);
-      toDo(ft, m_table ? ind++ : pos);
+      toDo(ft, m_table ? index++ : pos);
     });
   }
 
-  template <class ToDo> static void ForEachOffset(ModelReaderPtr reader, ToDo toDo)
+  template <class ToDo> static void ForEachOffset(ModelReaderPtr reader, ToDo && toDo)
   {
     VarRecordReader<ModelReaderPtr, &VarRecordSizeReaderVarint> recordReader(reader, 256);
     recordReader.ForEachRecord([&] (uint32_t pos, char const * /*data*/, uint32_t /*size*/)
@@ -43,11 +43,11 @@ public:
   }
 
 private:
+  friend class FeaturesVectorTest;
+
   feature::SharedLoadInfo m_LoadInfo;
   VarRecordReader<FilesContainerR::ReaderT, &VarRecordSizeReaderVarint> m_RecordReader;
   mutable vector<char> m_buffer;
-
-  friend class FeaturesVectorTest;
   feature::FeaturesOffsetsTable const * m_table;
 };
 
diff --git a/indexer/index.cpp b/indexer/index.cpp
index 560e38aac2..c34db7002a 100644
--- a/indexer/index.cpp
+++ b/indexer/index.cpp
@@ -108,8 +108,8 @@ bool Index::FeaturesLoaderGuard::IsWorld() const
   return m_handle.GetValue<MwmValue>()->GetHeader().GetType() == feature::DataHeader::world;
 }
 
-void Index::FeaturesLoaderGuard::GetFeatureByIndex(uint32_t ind, FeatureType & ft)
+void Index::FeaturesLoaderGuard::GetFeatureByIndex(uint32_t index, FeatureType & ft)
 {
-  m_vector.GetByIndex(ind, ft);
-  ft.SetID(FeatureID(m_handle.GetId(), ind));
+  m_vector.GetByIndex(index, ft);
+  ft.SetID(FeatureID(m_handle.GetId(), index));
 }
diff --git a/indexer/index.hpp b/indexer/index.hpp
index d7c21ba0d5..611fd7e8da 100644
--- a/indexer/index.hpp
+++ b/indexer/index.hpp
@@ -125,14 +125,14 @@ private:
 
         for (auto const & i : interval)
         {
-          index.ForEachInIntervalAndScale([&] (uint32_t ind)
+          index.ForEachInIntervalAndScale([&] (uint32_t index)
           {
-            if (checkUnique(ind))
+            if (checkUnique(index))
             {
               FeatureType feature;
 
-              fv.GetByIndex(ind, feature);
-              feature.SetID(FeatureID(mwmID, ind));
+              fv.GetByIndex(index, feature);
+              feature.SetID(FeatureID(mwmID, index));
 
               m_f(feature);
             }
@@ -172,10 +172,10 @@ private:
 
         for (auto const & i : interval)
         {
-          index.ForEachInIntervalAndScale([&] (uint32_t ind)
+          index.ForEachInIntervalAndScale([&] (uint32_t index)
           {
-            if (checkUnique(ind))
-              m_f(FeatureID(mwmID, ind));
+            if (checkUnique(index))
+              m_f(FeatureID(mwmID, index));
           }, i.first, i.second, scale);
         }
       }
@@ -230,7 +230,7 @@ public:
     inline MwmSet::MwmId GetId() const { return m_handle.GetId(); }
     string GetCountryFileName() const;
     bool IsWorld() const;
-    void GetFeatureByIndex(uint32_t ind, FeatureType & ft);
+    void GetFeatureByIndex(uint32_t index, FeatureType & ft);
 
   private:
     MwmHandle m_handle;
@@ -271,7 +271,7 @@ private:
         FeatureID const & featureId = features[result];
         FeatureType featureType;
 
-        featureReader.GetByIndex(featureId.m_ind, featureType);
+        featureReader.GetByIndex(featureId.m_index, featureType);
         featureType.SetID(featureId);
 
         f(featureType);
diff --git a/indexer/indexer.pro b/indexer/indexer.pro
index 5bbb1c88f4..dd251aa629 100644
--- a/indexer/indexer.pro
+++ b/indexer/indexer.pro
@@ -29,6 +29,7 @@ SOURCES += \
     feature_utils.cpp \
     feature_visibility.cpp \
     features_offsets_table.cpp \
+    features_vector.cpp \
     ftypes_matcher.cpp \
     geometry_coding.cpp \
     geometry_serialization.cpp \
@@ -46,7 +47,6 @@ SOURCES += \
     search_index_builder.cpp \
     search_string_utils.cpp \
     types_mapping.cpp \
-    features_vector.cpp \
 
 HEADERS += \
     categories_holder.hpp \
diff --git a/indexer/indexer_tests/test_mwm_set.hpp b/indexer/indexer_tests/test_mwm_set.hpp
index 8206465f7c..853d78b927 100644
--- a/indexer/indexer_tests/test_mwm_set.hpp
+++ b/indexer/indexer_tests/test_mwm_set.hpp
@@ -25,6 +25,7 @@ protected:
     info->m_version.format = version::lastFormat;
     return info;
   }
+
   MwmValueBase * CreateValue(MwmInfo &) const override
   {
     return new MwmValueBase();
diff --git a/indexer/mwm_set.cpp b/indexer/mwm_set.cpp
index 389354f314..3ced9905c6 100644
--- a/indexer/mwm_set.cpp
+++ b/indexer/mwm_set.cpp
@@ -291,24 +291,14 @@ void MwmSet::ClearCacheImpl(CacheType::iterator beg, CacheType::iterator end)
   m_cache.erase(beg, end);
 }
 
-namespace
-{
-  struct MwmIdIsEqualTo
-  {
-    MwmSet::MwmId m_id;
-
-    explicit MwmIdIsEqualTo(MwmSet::MwmId const & id) : m_id(id) {}
-
-    bool operator()(pair<MwmSet::MwmId, MwmSet::TMwmValueBasePtr> const & p) const
-    {
-      return p.first == m_id;
-    }
-  };
-}
-
 void MwmSet::ClearCache(MwmId const & id)
 {
-  ClearCacheImpl(RemoveIfKeepValid(m_cache.begin(), m_cache.end(), MwmIdIsEqualTo(id)), m_cache.end());
+  ClearCacheImpl(RemoveIfKeepValid(m_cache.begin(), m_cache.end(),
+  [&id] (pair<MwmSet::MwmId, MwmSet::TMwmValueBasePtr> const & p)
+  {
+    return (p.first == id);
+  }),
+  m_cache.end());
 }
 
 string DebugPrint(MwmSet::RegResult result)
@@ -324,6 +314,6 @@ string DebugPrint(MwmSet::RegResult result)
     case MwmSet::RegResult::BadFile:
       return "BadFile";
     case MwmSet::RegResult::UnsupportedFileFormat:
-    return "UnsupportedFileFormat";
+      return "UnsupportedFileFormat";
   }
 }
diff --git a/indexer/mwm_set.hpp b/indexer/mwm_set.hpp
index a5663da83b..8370a0f482 100644
--- a/indexer/mwm_set.hpp
+++ b/indexer/mwm_set.hpp
@@ -84,13 +84,12 @@ public:
     friend class MwmSet;
 
     MwmId() = default;
-    MwmId(MwmId const & id) = default;
     MwmId(shared_ptr<MwmInfo> const & info) : m_info(info) {}
 
     void Reset() { m_info.reset(); }
     bool IsAlive() const
     {
-      return m_info.get() != nullptr && m_info->GetStatus() != MwmInfo::STATUS_DEREGISTERED;
+      return (m_info && m_info->GetStatus() != MwmInfo::STATUS_DEREGISTERED);
     }
     shared_ptr<MwmInfo> const & GetInfo() const { return m_info; }
 
diff --git a/indexer/scale_index_builder.hpp b/indexer/scale_index_builder.hpp
index b644ea6d6c..94376b8c29 100644
--- a/indexer/scale_index_builder.hpp
+++ b/indexer/scale_index_builder.hpp
@@ -101,10 +101,10 @@ public:
   }
 
   template <class TFeature>
-  void operator() (TFeature const & f, uint32_t ind) const
+  void operator() (TFeature const & ft, uint32_t index) const
   {
     m_scalesIdx = 0;
-    uint32_t minScaleClassif = feature::GetMinDrawableScaleClassifOnly(f);
+    uint32_t minScaleClassif = feature::GetMinDrawableScaleClassifOnly(ft);
     // The classificator won't allow this feature to be drawable for smaller
     // scales so the first buckets can be safely skipped.
     // todo(@pimenov) Parallelizing this loop may be helpful.
@@ -114,14 +114,14 @@ public:
       // This is not immediately obvious and in fact there was an idea to map
       // a bucket to a contiguous range of scales.
       // todo(@pimenov): We probably should remove scale_index.hpp altogether.
-      if (!FeatureShouldBeIndexed(f, bucket, bucket == minScaleClassif /* needReset */))
+      if (!FeatureShouldBeIndexed(ft, bucket, bucket == minScaleClassif /* needReset */))
       {
         continue;
       }
 
-      vector<int64_t> const cells = covering::CoverFeature(f, m_codingDepth, 250);
+      vector<int64_t> const cells = covering::CoverFeature(ft, m_codingDepth, 250);
       for (int64_t cell : cells)
-        m_sorter.Add(CellFeatureBucketTuple(CellFeaturePair(cell, ind), bucket));
+        m_sorter.Add(CellFeatureBucketTuple(CellFeaturePair(cell, index), bucket));
 
       m_featuresInBucket[bucket] += 1;
       m_cellsInBucket[bucket] += cells.size();
@@ -137,7 +137,7 @@ private:
   //   -- it is allowed by the classificator.
   // If the feature is invisible at all scales, do not index it.
   template <class TFeature>
-  bool FeatureShouldBeIndexed(TFeature const & f, uint32_t scale, bool needReset) const
+  bool FeatureShouldBeIndexed(TFeature const & ft, uint32_t scale, bool needReset) const
   {
     while (m_scalesIdx < m_header.GetScalesCount() && m_header.GetScale(m_scalesIdx) < scale)
     {
@@ -146,16 +146,16 @@ private:
     }
 
     if (needReset)
-      f.ResetGeometry();
+      ft.ResetGeometry();
 
     // This function invokes geometry reading for the needed scale.
-    if (f.IsEmptyGeometry(scale))
+    if (ft.IsEmptyGeometry(scale))
       return false;
 
     // This function assumes that geometry rect for the needed scale is already initialized.
     // Note: it works with FeatureBase so in fact it does not use the information about
     // the feature's geometry except for the type and the LimitRect.
-    return feature::IsDrawableForIndexGeometryOnly(f, scale);
+    return feature::IsDrawableForIndexGeometryOnly(ft, scale);
   }
 
   // We do not need to parse a feature's geometry for every bucket.
diff --git a/indexer/search_index_builder.cpp b/indexer/search_index_builder.cpp
index b4d2b5a110..7ca3488fa1 100644
--- a/indexer/search_index_builder.cpp
+++ b/indexer/search_index_builder.cpp
@@ -158,15 +158,15 @@ struct ValueBuilder<SerializedFeatureInfoValue>
 
   ValueBuilder(serial::CodingParams const & cp) : m_valueSaver(cp) {}
 
-  void MakeValue(FeatureType const & f, feature::TypesHolder const & types, uint32_t ind,
+  void MakeValue(FeatureType const & ft, feature::TypesHolder const & types, uint32_t index,
                  SerializedFeatureInfoValue & value) const
   {
     SaverT::ValueType v;
-    v.m_featureId = ind;
+    v.m_featureId = index;
 
     // get BEST geometry rect of feature
-    v.m_pt = feature::GetCenter(f);
-    v.m_rank = feature::GetSearchRank(types, v.m_pt, f.GetPopulation());
+    v.m_pt = feature::GetCenter(ft);
+    v.m_rank = feature::GetSearchRank(types, v.m_pt, ft.GetPopulation());
 
     // write to buffer
     PushBackByteSink<SerializedFeatureInfoValue::ValueT> sink(value.m_value);
@@ -178,9 +178,9 @@ template <>
 struct ValueBuilder<FeatureIndexValue>
 {
   void MakeValue(FeatureType const & /* f */, feature::TypesHolder const & /* types */,
-                 uint32_t ind, FeatureIndexValue & value) const
+                 uint32_t index, FeatureIndexValue & value) const
   {
-    value.m_value = ind;
+    value.m_value = index;
   }
 };
 
@@ -313,7 +313,7 @@ public:
   {
   }
 
-  void operator() (FeatureType const & f, uint32_t ind) const
+  void operator() (FeatureType const & f, uint32_t index) const
   {
     feature::TypesHolder types(f);
 
@@ -327,7 +327,7 @@ public:
     // Insert synonyms only for countries and states (maybe will add cities in future).
     FeatureNameInserter<StringsFileT> inserter(skipIndex.IsCountryOrState(types) ? m_synonyms : 0,
                                                m_names);
-    m_valueBuilder.MakeValue(f, types, ind, inserter.m_val);
+    m_valueBuilder.MakeValue(f, types, index, inserter.m_val);
 
     // Skip types for features without names.
     if (!f.ForEachNameRef(inserter))
diff --git a/indexer/unique_index.hpp b/indexer/unique_index.hpp
index 41865773d0..14007b55a2 100644
--- a/indexer/unique_index.hpp
+++ b/indexer/unique_index.hpp
@@ -1,9 +1,9 @@
 #pragma once
 
-#include "../base/base.hpp"
+#include "base/base.hpp"
 
-#include "../std/unordered_set.hpp"
-#include "../std/vector.hpp"
+#include "std/unordered_set.hpp"
+#include "std/vector.hpp"
 
 
 class CheckUniqueIndexes
@@ -14,44 +14,40 @@ class CheckUniqueIndexes
 
   /// Add index to the set.
   /// @return true If index was absent.
-  bool Add(uint32_t ind)
+  bool Add(uint32_t index)
   {
-    if (m_useBits)
-    {
-      if (m_v.size() <= ind)
-        m_v.resize(ind + 1);
-      bool const ret = !m_v[ind];
-      m_v[ind] = true;
-      return ret;
-    }
-    else
-      return m_s.insert(ind).second;
+    if (!m_useBits)
+      return m_s.insert(index).second;
+
+    if (m_v.size() <= index)
+      m_v.resize(index + 1);
+    bool const ret = !m_v[index];
+    m_v[index] = true;
+    return ret;
   }
 
   /// Remove index from the set.
   /// @return true If index was present.
-  bool Remove(uint32_t ind)
+  bool Remove(uint32_t index)
   {
-    if (m_useBits)
+    if (!m_useBits)
+      return (m_s.erase(index) > 0);
+
+    if (m_v.size() > index)
     {
-      if (m_v.size() > ind)
-      {
-        bool const ret = m_v[ind];
-        m_v[ind] = false;
-        return ret;
-      }
-      else
-        return false;
+      bool const ret = m_v[index];
+      m_v[index] = false;
+      return ret;
     }
     else
-      return (m_s.erase(ind) > 0);
+      return false;
   }
 
 public:
   explicit CheckUniqueIndexes(bool useBits) : m_useBits(useBits) {}
 
-  bool operator()(uint32_t ind)
+  bool operator()(uint32_t index)
   {
-    return Add(ind);
+    return Add(index);
   }
 };
diff --git a/map/framework.cpp b/map/framework.cpp
index 90b18b566f..8817399de7 100644
--- a/map/framework.cpp
+++ b/map/framework.cpp
@@ -1340,7 +1340,7 @@ void Framework::ShowSearchResult(search::Result const & res)
       Index::FeaturesLoaderGuard guard(m_model.GetIndex(), id.m_mwmId);
 
       FeatureType ft;
-      guard.GetFeatureByIndex(id.m_ind, ft);
+      guard.GetFeatureByIndex(id.m_index, ft);
 
       scale = GetFeatureViewportScale(TypesHolder(ft));
       center = GetCenter(ft, scale);
@@ -1807,10 +1807,10 @@ bool Framework::GetVisiblePOI(m2::PointD const & pxPoint, m2::PointD & pxPivot,
 
   if (ui.IsValid())
   {
-    Index::FeaturesLoaderGuard guard(m_model.GetIndex(), ui.m_mwmID);
+    Index::FeaturesLoaderGuard guard(m_model.GetIndex(), ui.m_featureID.m_mwmId);
 
     FeatureType ft;
-    guard.GetFeatureByIndex(ui.m_fID, ft);
+    guard.GetFeatureByIndex(ui.m_featureID.m_index, ft);
 
     ft.ParseMetadata();
     metadata = ft.GetMetadata();
@@ -1866,7 +1866,7 @@ public:
     Index::FeaturesLoaderGuard guard(model.GetIndex(), m_id.m_mwmId);
 
     FeatureType ft;
-    guard.GetFeatureByIndex(m_id.m_ind, ft);
+    guard.GetFeatureByIndex(m_id.m_index, ft);
 
     ft.ParseMetadata();
     metadata = ft.GetMetadata();
diff --git a/map/mwm_tests/mwm_foreach_test.cpp b/map/mwm_tests/mwm_foreach_test.cpp
index f9f8c3a3f4..ef6250a153 100644
--- a/map/mwm_tests/mwm_foreach_test.cpp
+++ b/map/mwm_tests/mwm_foreach_test.cpp
@@ -49,12 +49,12 @@ protected:
   void add(FeatureType const & f) const
   {
     TEST(f.GetID().IsValid(), ());
-    m_cont.push_back(f.GetID().m_ind);
+    m_cont.push_back(f.GetID().m_index);
   }
 
-  void add(FeatureType const &, uint32_t ind) const
+  void add(FeatureType const &, uint32_t index) const
   {
-    m_cont.push_back(ind);
+    m_cont.push_back(index);
   }
 
 public:
@@ -167,10 +167,10 @@ public:
   {
   }
 
-  void operator() (FeatureType const & f, uint32_t ind) const
+  void operator() (FeatureType const & f, uint32_t index) const
   {
     if (is_drawable(f) && is_intersect(f))
-      add(f, ind);
+      add(f, index);
   }
 };
 
@@ -231,18 +231,18 @@ class FindOffset
   uint32_t m_index;
 
 public:
-  FindOffset(int level, uint32_t ind)
-    : m_level(level), m_index(ind)
+  FindOffset(int level, uint32_t index)
+    : m_level(level), m_index(index)
   {}
 
-  void operator() (FeatureType const & f, uint32_t ind)
+  void operator() (FeatureType const & ft, uint32_t index)
   {
-    if (ind == m_index)
+    if (index == m_index)
     {
-      TEST(IsDrawable(f, m_level), ());
+      TEST(IsDrawable(ft, m_level), ());
 
-      LOG(LINFO, ("Feature index:", ind));
-      LOG(LINFO, ("Feature:", f));
+      LOG(LINFO, ("Feature index:", index));
+      LOG(LINFO, ("Feature:", ft));
     }
   }
 };
diff --git a/platform/platform_linux.cpp b/platform/platform_linux.cpp
index e9b76209a5..d111f7c7a7 100644
--- a/platform/platform_linux.cpp
+++ b/platform/platform_linux.cpp
@@ -32,7 +32,7 @@ Platform::Platform()
   char const * homePath = ::getenv("HOME");
   string const home(homePath ? homePath : "");
 
-  m_settingsDir = home + "/.config/MapsWithMe/";
+  m_settingsDir = home + "/.config/MapsWithMe";
 
   if (!IsFileExistsByFullPath(m_settingsDir + SETTINGS_FILE_NAME))
   {
diff --git a/render/gpu_drawer.cpp b/render/gpu_drawer.cpp
index e655abc36d..cc3f756e75 100644
--- a/render/gpu_drawer.cpp
+++ b/render/gpu_drawer.cpp
@@ -14,8 +14,7 @@ namespace
   graphics::OverlayElement::UserInfo ToUserInfo(FeatureID const & id)
   {
     graphics::OverlayElement::UserInfo info;
-    info.m_fID = id.m_ind;
-    info.m_mwmID = id.m_mwmId;
+    info.m_featureID = id;
     return info;
   }
 }
diff --git a/routing/features_road_graph.cpp b/routing/features_road_graph.cpp
index 2edb0850f3..c564591993 100644
--- a/routing/features_road_graph.cpp
+++ b/routing/features_road_graph.cpp
@@ -94,7 +94,7 @@ IRoadGraph::RoadInfo & FeaturesRoadGraph::RoadInfoCache::Find(FeatureID const &
   auto res = m_cache.insert(make_pair(featureId.m_mwmId, TMwmFeatureCache()));
   if (res.second)
     res.first->second.Init(kPowOfTwoForFeatureCacheSize);
-  return res.first->second.Find(featureId.m_ind, found);
+  return res.first->second.Find(featureId.m_index, found);
 }
 
 void FeaturesRoadGraph::RoadInfoCache::Clear()
@@ -201,7 +201,7 @@ void FeaturesRoadGraph::GetFeatureTypes(FeatureID const & featureId, feature::Ty
 {
   FeatureType ft;
   Index::FeaturesLoaderGuard loader(m_index, featureId.m_mwmId);
-  loader.GetFeature(featureId.m_offset, ft);
+  loader.GetFeatureByIndex(featureId.m_index, ft);
   ASSERT_EQUAL(ft.GetFeatureType(), feature::GEOM_LINE, ());
 
   types = feature::TypesHolder(ft);
@@ -234,7 +234,7 @@ IRoadGraph::RoadInfo const & FeaturesRoadGraph::GetCachedRoadInfo(FeatureID cons
 
   FeatureType ft;
   Index::FeaturesLoaderGuard loader(m_index, featureId.m_mwmId);
-  loader.GetFeatureByIndex(featureId.m_ind, ft);
+  loader.GetFeatureByIndex(featureId.m_index, ft);
   ASSERT_EQUAL(ft.GetFeatureType(), feature::GEOM_LINE, ());
 
   ft.ParseGeometry(FeatureType::BEST_GEOMETRY);
diff --git a/routing/osrm_router.cpp b/routing/osrm_router.cpp
index 52ca222db8..99aca205e6 100644
--- a/routing/osrm_router.cpp
+++ b/routing/osrm_router.cpp
@@ -75,7 +75,7 @@ public:
     ft.ParseGeometry(FeatureType::BEST_GEOMETRY);
 
     size_t const count = ft.GetPointsCount();
-    uint32_t const featureId = ft.GetID().m_ind;
+    uint32_t const featureId = ft.GetID().m_index;
     ASSERT_GREATER(count, 1, ());
     for (size_t i = 1; i < count; ++i)
     {
diff --git a/routing/routing_tests/road_graph_builder.cpp b/routing/routing_tests/road_graph_builder.cpp
index 0bd749463b..28fdfe0e9b 100644
--- a/routing/routing_tests/road_graph_builder.cpp
+++ b/routing/routing_tests/road_graph_builder.cpp
@@ -68,14 +68,14 @@ void RoadGraphMockSource::AddRoad(RoadInfo && ri)
 
 IRoadGraph::RoadInfo RoadGraphMockSource::GetRoadInfo(FeatureID const & featureId) const
 {
-  CHECK_LESS(featureId.m_ind, m_roads.size(), ("Invalid feature id."));
-  return m_roads[featureId.m_ind];
+  CHECK_LESS(featureId.m_index, m_roads.size(), ("Invalid feature id."));
+  return m_roads[featureId.m_index];
 }
 
 double RoadGraphMockSource::GetSpeedKMPH(FeatureID const & featureId) const
 {
-  CHECK_LESS(featureId.m_ind, m_roads.size(), ("Invalid feature id."));
-  return m_roads[featureId.m_ind].m_speedKMPH;
+  CHECK_LESS(featureId.m_index, m_roads.size(), ("Invalid feature id."));
+  return m_roads[featureId.m_index].m_speedKMPH;
 }
 
 double RoadGraphMockSource::GetMaxSpeedKMPH() const
diff --git a/routing/turns_generator.cpp b/routing/turns_generator.cpp
index d9bb7163fd..cd2dd68630 100644
--- a/routing/turns_generator.cpp
+++ b/routing/turns_generator.cpp
@@ -113,7 +113,7 @@ public:
     static CarModel const carModel;
     if (ft.GetFeatureType() != feature::GEOM_LINE || !carModel.IsRoad(ft))
       return;
-    uint32_t const featureId = ft.GetID().m_ind;
+    uint32_t const featureId = ft.GetID().m_index;
     for (auto const n : m_routingMapping.m_segMapping.GetNodeIdByFid(featureId))
       n_nodeIds.push_back(n);
   }
diff --git a/search/house_detector.cpp b/search/house_detector.cpp
index 2c74c28e11..9b625163a7 100644
--- a/search/house_detector.cpp
+++ b/search/house_detector.cpp
@@ -242,7 +242,7 @@ void FeatureLoader::CreateLoader(MwmSet::MwmId const & mwmId)
 void FeatureLoader::Load(FeatureID const & id, FeatureType & f)
 {
   CreateLoader(id.m_mwmId);
-  m_pGuard->GetFeatureByIndex(id.m_ind, f);
+  m_pGuard->GetFeatureByIndex(id.m_index, f);
 }
 
 void FeatureLoader::Free()
diff --git a/search/search_query.cpp b/search/search_query.cpp
index 5bc6770df7..722c084822 100644
--- a/search/search_query.cpp
+++ b/search/search_query.cpp
@@ -593,7 +593,7 @@ namespace impl
       if (m_pFV.get() == 0 || m_pFV->GetId() != id.m_mwmId)
         m_pFV.reset(new Index::FeaturesLoaderGuard(*m_query.m_pIndex, id.m_mwmId));
 
-      m_pFV->GetFeatureByIndex(id.m_ind, f);
+      m_pFV->GetFeatureByIndex(id.m_index, f);
       f.SetID(id);
 
       m_query.GetBestMatchName(f, name);