diff --git a/data/minsk-pass.mwm b/data/minsk-pass.mwm
index ca6fbe4ff9..9c1ef2e461 100644
Binary files a/data/minsk-pass.mwm and b/data/minsk-pass.mwm differ
diff --git a/indexer/feature.cpp b/indexer/feature.cpp
index 8d0ebc94a5..ec48991d9e 100644
--- a/indexer/feature.cpp
+++ b/indexer/feature.cpp
@@ -495,13 +495,36 @@ void FeatureType::Deserialize(read_source_t & src)
   base_type::Deserialize(src.m_data, src.m_offset);
 }
 
-uint32_t FeatureType::GetOffset(int scale, offsets_t const & offsets) const
+namespace
 {
-  for (size_t i = 0; i < ARRAY_SIZE(feature::g_arrScales); ++i)
-    if (scale <= feature::g_arrScales[i])
-      return offsets[i];
+    uint32_t const kInvalidOffset = uint32_t(-1);
+}
 
-  return kInvalidOffset;
+int FeatureType::GetScaleIndex(int scale, offsets_t const & offsets) const
+{
+  if (scale == -1)
+  {
+    // Choose the best geometry for the last visible scale.
+    int i = offsets.size()-1;
+    while (i >= 0 && offsets[i] == kInvalidOffset) --i;
+    if (i >= 0)
+      return i;
+    else
+      CHECK ( false, ("Feature should have any geometry ...") );
+  }
+  else
+  {
+    for (size_t i = 0; i < ARRAY_SIZE(feature::g_arrScales); ++i)
+      if (scale <= feature::g_arrScales[i])
+      {
+        if (offsets[i] != kInvalidOffset)
+          return i;
+        else
+          break;
+      }
+  }
+
+  return -1;
 }
 
 namespace
@@ -565,16 +588,16 @@ uint32_t FeatureType::ParseGeometry(int scale) const
   uint32_t sz = 0;
   if (Header() & HEADER_IS_LINE)
   {
-    uint32_t const offset = GetOffset(scale, m_lineOffsets);
-    if (offset != kInvalidOffset)
+    int const ind = GetScaleIndex(scale, m_lineOffsets);
+    if (ind != -1)
     {
       ReaderSource<FileReader> src(
-            m_cont->GetReader(feature::GetTagForScale(GEOMETRY_FILE_TAG, scale)));
-      src.Skip(offset);
+            m_cont->GetReader(feature::GetTagForIndex(GEOMETRY_FILE_TAG, ind)));
+      src.Skip(m_lineOffsets[ind]);
       feature::LoadPoints(m_Geometry, src);
 
       CalcRect(m_Geometry, m_LimitRect);
-      sz = static_cast<uint32_t>(src.Pos() - offset);
+      sz = static_cast<uint32_t>(src.Pos() - m_lineOffsets[ind]);
     }
   }
 
@@ -590,16 +613,16 @@ uint32_t FeatureType::ParseTriangles(int scale) const
   uint32_t sz = 0;
   if (Header() & HEADER_IS_AREA)
   {
-    uint32_t const offset = GetOffset(scale, m_trgOffsets);
-    if (offset != kInvalidOffset)
+    uint32_t const ind = GetScaleIndex(scale, m_trgOffsets);
+    if (ind != -1)
     {
       ReaderSource<FileReader> src(
-            m_cont->GetReader(feature::GetTagForScale(TRIANGLE_FILE_TAG, scale)));
-      src.Skip(offset);
+            m_cont->GetReader(feature::GetTagForIndex(TRIANGLE_FILE_TAG, ind)));
+      src.Skip(m_trgOffsets[ind]);
       feature::LoadTriangles(m_Triangles, src);
 
       CalcRect(m_Triangles, m_LimitRect);
-      sz = static_cast<uint32_t>(src.Pos() - offset);
+      sz = static_cast<uint32_t>(src.Pos() - m_trgOffsets[ind]);
     }
   }
 
diff --git a/indexer/feature.hpp b/indexer/feature.hpp
index 19c01f988c..5d423ade3e 100644
--- a/indexer/feature.hpp
+++ b/indexer/feature.hpp
@@ -434,9 +434,7 @@ private:
 
   static void ReadOffsetsImpl(ArrayByteSource & src, offsets_t & offsets);
 
-  static uint32_t const kInvalidOffset = uint32_t(-1);
-
-  uint32_t GetOffset(int scale, offsets_t const & offset) const;
+  int GetScaleIndex(int scale, offsets_t const & offset) const;
 
   mutable offsets_t m_lineOffsets, m_trgOffsets;
 };
diff --git a/indexer/feature_impl.hpp b/indexer/feature_impl.hpp
index 269619e4bb..dc7eea151c 100644
--- a/indexer/feature_impl.hpp
+++ b/indexer/feature_impl.hpp
@@ -119,7 +119,7 @@ namespace feature
 
   static int g_arrScales[] = { 5, 10, 14, 17 };  // 17 = scales::GetUpperScale()
 
-  inline string GetTagForScale(char const * prefix, int scale)
+  inline string GetTagForIndex(char const * prefix, int ind)
   {
     string str;
     str.reserve(strlen(prefix) + 1);
@@ -127,14 +127,9 @@ namespace feature
 
     static char arrChar[] = { '0', '1', '2', '3' };
     STATIC_ASSERT ( ARRAY_SIZE(arrChar) == ARRAY_SIZE(g_arrScales) );
+    ASSERT ( ind >= 0 && ind < ARRAY_SIZE(arrChar), (ind) );
 
-    for (size_t i = 0; i < ARRAY_SIZE(feature::g_arrScales); ++i)
-      if (scale <= feature::g_arrScales[i])
-      {
-        str += arrChar[i];
-        break;
-      }
-
+    str += arrChar[ind];
     return str;
   }
 }
diff --git a/indexer/scale_index_builder.hpp b/indexer/scale_index_builder.hpp
index d301deb2ce..1184e93316 100644
--- a/indexer/scale_index_builder.hpp
+++ b/indexer/scale_index_builder.hpp
@@ -49,6 +49,13 @@ STATIC_ASSERT(sizeof(CellFeaturePair) == 12);
 template <class SorterT>
 class FeatureCoverer
 {
+  int GetGeometryScale() const
+  {
+    // Do not pass actual level. We should build index for the best geometry (pass -1).
+    return -1;
+    //return m_ScaleRange.second-1;
+  }
+
 public:
   FeatureCoverer(uint32_t bucket,
                  SorterT & sorter,
@@ -64,7 +71,7 @@ public:
   {
     if (FeatureShouldBeIndexed(f))
     {
-      vector<int64_t> const cells = covering::CoverFeature(f, m_ScaleRange.second-1);
+      vector<int64_t> const cells = covering::CoverFeature(f, GetGeometryScale());
       for (vector<int64_t>::const_iterator it = cells.begin(); it != cells.end(); ++it)
         m_Sorter.Add(CellFeaturePair(*it, offset));
       ++m_NumFeatures;
@@ -75,8 +82,8 @@ public:
   template <class TFeature>
   bool FeatureShouldBeIndexed(TFeature const & f) const
   {
-     if (f.IsEmptyGeometry(m_ScaleRange.second-1))
-       return false;
+    if (f.IsEmptyGeometry(GetGeometryScale()))
+      return false;
 
     uint32_t const minScale = feature::MinDrawableScaleForFeature(f);
     return (m_ScaleRange.first <= minScale && minScale < m_ScaleRange.second);