diff --git a/geometry/cellid.hpp b/geometry/cellid.hpp
index 509747eacb..f37054c328 100644
--- a/geometry/cellid.hpp
+++ b/geometry/cellid.hpp
@@ -74,10 +74,10 @@ public:
     return m_Bits & 3;
   }
 
-  uint64_t SubTreeSize(int depth = DEPTH_LEVELS) const
+  uint64_t SubTreeSize(int depth) const
   {
     ASSERT(IsValid(), (m_Bits, m_Level));
-    ASSERT_LESS(m_Level, depth, (m_Bits, m_Level, depth));
+    ASSERT(m_Level < depth && depth <= DEPTH_LEVELS, (m_Bits, m_Level, depth));
     return TreeSizeForDepth(depth - m_Level);
   }
 
@@ -222,13 +222,13 @@ public:
   // Numbering
 
   // Default ToInt64().
-  int64_t ToInt64(int depth = DEPTH_LEVELS) const
+  int64_t ToInt64(int depth) const
   {
     return ToInt64LevelZOrder(depth);
   }
 
   // Default FromInt64().
-  static CellId FromInt64(int64_t v, int depth = DEPTH_LEVELS)
+  static CellId FromInt64(int64_t v, int depth)
   {
     return FromInt64LevelZOrder(v, depth);
   }
@@ -236,6 +236,7 @@ public:
   // Level order, numbering by Z-curve.
   int64_t ToInt64LevelZOrder(int depth) const
   {
+    ASSERT(0 < depth && depth <= DEPTH_LEVELS, (m_Bits, m_Level, depth));
     ASSERT(IsValid(), (m_Bits, m_Level));
     uint64_t bits = m_Bits, res = 0;
     for (int i = 0; i <= m_Level; ++i, bits >>= 2)
@@ -255,6 +256,7 @@ public:
   static CellId FromInt64LevelZOrder(int64_t v, int depth)
   {
     ASSERT_GREATER(v, 0, ());
+    ASSERT(0 < depth && depth <= DEPTH_LEVELS, (v, depth));
     ASSERT_LESS_OR_EQUAL(v, TreeSizeForDepth(depth), ());
     uint64_t bits = 0;
     int level = 0;
@@ -275,7 +277,7 @@ private:
 
   static uint64_t TreeSizeForDepth(int depth)
   {
-    ASSERT_GREATER(depth, 0, ());
+    ASSERT(0 < depth && depth <= DEPTH_LEVELS, (depth));
     return ((1ULL << 2 * depth) - 1) / 3ULL;
   }
 
diff --git a/geometry/covering.hpp b/geometry/covering.hpp
index 0d2174b6cd..2a50ccc3f3 100644
--- a/geometry/covering.hpp
+++ b/geometry/covering.hpp
@@ -81,11 +81,11 @@ public:
         result.insert(result.end(), m_Covering[level].begin(), m_Covering[level].end());
   }
 
-  void OutputToVector(vector<int64_t> & result) const
+  void OutputToVector(vector<int64_t> & result, int cellDepth) const
   {
     for (int level = 0; level < CellId::DEPTH_LEVELS; ++level)
       for (size_t i = 0; i < m_Covering[level].size(); ++i)
-        result.push_back(m_Covering[level][i].ToInt64());
+        result.push_back(m_Covering[level][i].ToInt64(cellDepth));
   }
 
   void Simplify()
@@ -182,7 +182,7 @@ private:
     RemoveDuplicateChildrenImpl();
 #ifdef DEBUG
     // Assert that all duplicate children were removed.
-    vector<int64_t> v1, v2;
+    vector<CellId> v1, v2;
     OutputToVector(v1);
     RemoveDuplicateChildrenImpl();
     OutputToVector(v2);
diff --git a/geometry/geometry_tests/cellid_test.cpp b/geometry/geometry_tests/cellid_test.cpp
index 389b686c88..07e7ed2ec7 100644
--- a/geometry/geometry_tests/cellid_test.cpp
+++ b/geometry/geometry_tests/cellid_test.cpp
@@ -33,38 +33,38 @@ UNIT_TEST(CellId_ToString)
 
 UNIT_TEST(CellId_ToInt64)
 {
-  TEST_EQUAL(m2::CellId<3>("").ToInt64(), 1, ());
-  TEST_EQUAL(m2::CellId<3>("0").ToInt64(), 2, ());
-  TEST_EQUAL(m2::CellId<3>("1").ToInt64(), 7, ());
-  TEST_EQUAL(m2::CellId<3>("2").ToInt64(), 12, ());
-  TEST_EQUAL(m2::CellId<3>("3").ToInt64(), 17, ());
-  TEST_EQUAL(m2::CellId<3>("00").ToInt64(), 3, ());
-  TEST_EQUAL(m2::CellId<3>("01").ToInt64(), 4, ());
-  TEST_EQUAL(m2::CellId<3>("03").ToInt64(), 6, ());
-  TEST_EQUAL(m2::CellId<3>("10").ToInt64(), 8, ());
-  TEST_EQUAL(m2::CellId<3>("20").ToInt64(), 13, ());
-  TEST_EQUAL(m2::CellId<3>("23").ToInt64(), 16, ());
-  TEST_EQUAL(m2::CellId<3>("30").ToInt64(), 18, ());
-  TEST_EQUAL(m2::CellId<3>("31").ToInt64(), 19, ());
-  TEST_EQUAL(m2::CellId<3>("33").ToInt64(), 21, ());
+  TEST_EQUAL(m2::CellId<3>("").ToInt64(3), 1, ());
+  TEST_EQUAL(m2::CellId<3>("0").ToInt64(3), 2, ());
+  TEST_EQUAL(m2::CellId<3>("1").ToInt64(3), 7, ());
+  TEST_EQUAL(m2::CellId<3>("2").ToInt64(3), 12, ());
+  TEST_EQUAL(m2::CellId<3>("3").ToInt64(3), 17, ());
+  TEST_EQUAL(m2::CellId<3>("00").ToInt64(3), 3, ());
+  TEST_EQUAL(m2::CellId<3>("01").ToInt64(3), 4, ());
+  TEST_EQUAL(m2::CellId<3>("03").ToInt64(3), 6, ());
+  TEST_EQUAL(m2::CellId<3>("10").ToInt64(3), 8, ());
+  TEST_EQUAL(m2::CellId<3>("20").ToInt64(3), 13, ());
+  TEST_EQUAL(m2::CellId<3>("23").ToInt64(3), 16, ());
+  TEST_EQUAL(m2::CellId<3>("30").ToInt64(3), 18, ());
+  TEST_EQUAL(m2::CellId<3>("31").ToInt64(3), 19, ());
+  TEST_EQUAL(m2::CellId<3>("33").ToInt64(3), 21, ());
 }
 
 UNIT_TEST(CellId_FromInt64)
 {
-  TEST_EQUAL(m2::CellId<3>(""), m2::CellId<3>::FromInt64(1), ());
-  TEST_EQUAL(m2::CellId<3>("0"), m2::CellId<3>::FromInt64(2), ());
-  TEST_EQUAL(m2::CellId<3>("1"), m2::CellId<3>::FromInt64(7), ());
-  TEST_EQUAL(m2::CellId<3>("2"), m2::CellId<3>::FromInt64(12), ());
-  TEST_EQUAL(m2::CellId<3>("3"), m2::CellId<3>::FromInt64(17), ());
-  TEST_EQUAL(m2::CellId<3>("00"), m2::CellId<3>::FromInt64(3), ());
-  TEST_EQUAL(m2::CellId<3>("01"), m2::CellId<3>::FromInt64(4), ());
-  TEST_EQUAL(m2::CellId<3>("03"), m2::CellId<3>::FromInt64(6), ());
-  TEST_EQUAL(m2::CellId<3>("10"), m2::CellId<3>::FromInt64(8), ());
-  TEST_EQUAL(m2::CellId<3>("20"), m2::CellId<3>::FromInt64(13), ());
-  TEST_EQUAL(m2::CellId<3>("23"), m2::CellId<3>::FromInt64(16), ());
-  TEST_EQUAL(m2::CellId<3>("30"), m2::CellId<3>::FromInt64(18), ());
-  TEST_EQUAL(m2::CellId<3>("31"), m2::CellId<3>::FromInt64(19), ());
-  TEST_EQUAL(m2::CellId<3>("33"), m2::CellId<3>::FromInt64(21), ());
+  TEST_EQUAL(m2::CellId<3>(""), m2::CellId<3>::FromInt64(1, 3), ());
+  TEST_EQUAL(m2::CellId<3>("0"), m2::CellId<3>::FromInt64(2, 3), ());
+  TEST_EQUAL(m2::CellId<3>("1"), m2::CellId<3>::FromInt64(7, 3), ());
+  TEST_EQUAL(m2::CellId<3>("2"), m2::CellId<3>::FromInt64(12, 3), ());
+  TEST_EQUAL(m2::CellId<3>("3"), m2::CellId<3>::FromInt64(17, 3), ());
+  TEST_EQUAL(m2::CellId<3>("00"), m2::CellId<3>::FromInt64(3, 3), ());
+  TEST_EQUAL(m2::CellId<3>("01"), m2::CellId<3>::FromInt64(4, 3), ());
+  TEST_EQUAL(m2::CellId<3>("03"), m2::CellId<3>::FromInt64(6, 3), ());
+  TEST_EQUAL(m2::CellId<3>("10"), m2::CellId<3>::FromInt64(8, 3), ());
+  TEST_EQUAL(m2::CellId<3>("20"), m2::CellId<3>::FromInt64(13, 3), ());
+  TEST_EQUAL(m2::CellId<3>("23"), m2::CellId<3>::FromInt64(16, 3), ());
+  TEST_EQUAL(m2::CellId<3>("30"), m2::CellId<3>::FromInt64(18, 3), ());
+  TEST_EQUAL(m2::CellId<3>("31"), m2::CellId<3>::FromInt64(19, 3), ());
+  TEST_EQUAL(m2::CellId<3>("33"), m2::CellId<3>::FromInt64(21, 3), ());
 }
 
 UNIT_TEST(CellId_XY)
@@ -118,13 +118,13 @@ UNIT_TEST(CellId_FromXY_XY_Match)
 
 UNIT_TEST(CellId_SubTreeSize)
 {
-  TEST_EQUAL(m2::CellId<3>("00").SubTreeSize(), 1, ());
-  TEST_EQUAL(m2::CellId<3>("22").SubTreeSize(), 1, ());
-  TEST_EQUAL(m2::CellId<3>("33").SubTreeSize(), 1, ());
-  TEST_EQUAL(m2::CellId<3>("0").SubTreeSize(), 5, ());
-  TEST_EQUAL(m2::CellId<3>("1").SubTreeSize(), 5, ());
-  TEST_EQUAL(m2::CellId<3>("3").SubTreeSize(), 5, ());
-  TEST_EQUAL(m2::CellId<3>("").SubTreeSize(), 21, ());
+  TEST_EQUAL(m2::CellId<3>("00").SubTreeSize(3), 1, ());
+  TEST_EQUAL(m2::CellId<3>("22").SubTreeSize(3), 1, ());
+  TEST_EQUAL(m2::CellId<3>("33").SubTreeSize(3), 1, ());
+  TEST_EQUAL(m2::CellId<3>("0").SubTreeSize(3), 5, ());
+  TEST_EQUAL(m2::CellId<3>("1").SubTreeSize(3), 5, ());
+  TEST_EQUAL(m2::CellId<3>("3").SubTreeSize(3), 5, ());
+  TEST_EQUAL(m2::CellId<3>("").SubTreeSize(3), 21, ());
 }
 
 UNIT_TEST(CellID_LessQueueOrder)
diff --git a/geometry/geometry_tests/covering_test.cpp b/geometry/geometry_tests/covering_test.cpp
index a9b7b13d40..4165134919 100644
--- a/geometry/geometry_tests/covering_test.cpp
+++ b/geometry/geometry_tests/covering_test.cpp
@@ -105,7 +105,7 @@ UNIT_TEST(Covering_EmptyTriangle)
 {
   m2::PointU pt(27, 31);
   CellId const expectedCellId = CellId::FromXY(pt.x, pt.y, CellId::DEPTH_LEVELS - 1);
-  TEST_GREATER(expectedCellId.ToInt64(), 5, ());
+  TEST_GREATER(expectedCellId.ToInt64(CellId::DEPTH_LEVELS), 5, ());
   covering::Covering<CellId> covering(pt, pt, pt);
   vector<CellId> ids;
   covering.OutputToVector(ids);
diff --git a/indexer/feature_covering.cpp b/indexer/feature_covering.cpp
index 3ecd715d67..66c4054770 100644
--- a/indexer/feature_covering.cpp
+++ b/indexer/feature_covering.cpp
@@ -92,7 +92,7 @@ public:
 namespace covering
 {
 
-vector<int64_t> CoverFeature(FeatureType const & f, uint64_t cellPenaltyArea)
+vector<int64_t> CoverFeature(FeatureType const & f, int cellDepth, uint64_t cellPenaltyArea)
 {
   FeatureIntersector featureIntersector;
   f.ForEachPointRef(featureIntersector, -1);
@@ -106,7 +106,7 @@ vector<int64_t> CoverFeature(FeatureType const & f, uint64_t cellPenaltyArea)
     m2::PointD pt = featureIntersector.m_Polyline[0];
     return vector<int64_t>(
           1, RectId::FromXY(static_cast<uint32_t>(pt.x), static_cast<uint32_t>(pt.y),
-                            RectId::DEPTH_LEVELS - 1).ToInt64());
+                            RectId::DEPTH_LEVELS - 1).ToInt64(cellDepth));
   }
 
   vector<RectId> cells;
@@ -114,7 +114,7 @@ vector<int64_t> CoverFeature(FeatureType const & f, uint64_t cellPenaltyArea)
 
   vector<int64_t> res(cells.size());
   for (size_t i = 0; i < cells.size(); ++i)
-    res[i] = cells[i].ToInt64();
+    res[i] = cells[i].ToInt64(cellDepth);
 
   return res;
 }
@@ -141,19 +141,19 @@ IntervalsT SortAndMergeIntervals(IntervalsT v)
   return res;
 }
 
-void AppendLowerLevels(RectId id, IntervalsT & intervals)
+void AppendLowerLevels(RectId id, int cellDepth, IntervalsT & intervals)
 {
-  int64_t idInt64 = id.ToInt64();
-  intervals.push_back(make_pair(idInt64, idInt64 + id.SubTreeSize()));
+  int64_t idInt64 = id.ToInt64(cellDepth);
+  intervals.push_back(make_pair(idInt64, idInt64 + id.SubTreeSize(cellDepth)));
   while (id.Level() > 0)
   {
     id = id.Parent();
-    idInt64 = id.ToInt64();
+    idInt64 = id.ToInt64(cellDepth);
     intervals.push_back(make_pair(idInt64, idInt64 + 1));
   }
 }
 
-IntervalsT CoverViewportAndAppendLowerLevels(m2::RectD const & r)
+IntervalsT CoverViewportAndAppendLowerLevels(m2::RectD const & r, int cellDepth)
 {
   vector<RectId> ids;
   CoverRect<MercatorBounds, RectId>(r.minX(), r.minY(), r.maxX(), r.maxY(), 8, ids);
@@ -162,7 +162,7 @@ IntervalsT CoverViewportAndAppendLowerLevels(m2::RectD const & r)
   intervals.reserve(ids.size() * 4);
 
   for (size_t i = 0; i < ids.size(); ++i)
-    AppendLowerLevels(ids[i], intervals);
+    AppendLowerLevels(ids[i], cellDepth, intervals);
 
   return SortAndMergeIntervals(intervals);
 }
diff --git a/indexer/feature_covering.hpp b/indexer/feature_covering.hpp
index d171cf1edf..955052bd83 100644
--- a/indexer/feature_covering.hpp
+++ b/indexer/feature_covering.hpp
@@ -16,12 +16,13 @@ namespace covering
 
   // Cover feature with RectIds and return their integer representations.
   vector<int64_t> CoverFeature(FeatureType const & feature,
+                               int cellDepth,
                                uint64_t cellPenaltyArea);
 
-  void AppendLowerLevels(RectId id, IntervalsT & intervals);
+  void AppendLowerLevels(RectId id, int cellDepth, IntervalsT & intervals);
 
   // Cover viewport with RectIds and append their RectIds as well.
-  IntervalsT CoverViewportAndAppendLowerLevels(m2::RectD const & rect);
+  IntervalsT CoverViewportAndAppendLowerLevels(m2::RectD const & rect, int cellDepth);
 
   // Given a vector of intervals [a, b), sort them and merge overlapping intervals.
   IntervalsT SortAndMergeIntervals(IntervalsT intervals);
diff --git a/indexer/index.hpp b/indexer/index.hpp
index 32570960c4..f814f245fe 100644
--- a/indexer/index.hpp
+++ b/indexer/index.hpp
@@ -46,7 +46,8 @@ public:
   template <typename F>
   void ForEachInRect(F & f, m2::RectD const & rect, uint32_t scale) const
   {
-    CallForIntervals(f, covering::CoverViewportAndAppendLowerLevels(rect), rect, scale);
+    CallForIntervals(f, covering::CoverViewportAndAppendLowerLevels(rect, RectId::DEPTH_LEVELS),
+                     rect, scale);
   }
 
   template <typename F>
@@ -55,7 +56,7 @@ public:
     using namespace covering;
 
     IntervalsT intervals;
-    AppendLowerLevels(GetRectIdAsIs(rect), intervals);
+    AppendLowerLevels(GetRectIdAsIs(rect), RectId::DEPTH_LEVELS, intervals);
 
     CallForIntervals(f, intervals, rect, scale);
   }
@@ -64,8 +65,7 @@ public:
   template <typename F>
   void ForEachInScale(F & f, uint32_t scale) const
   {
-    int64_t const rootId = RectId("").ToInt64();
-    BaseT::ForEachInIntervalAndScale(f, rootId, rootId + RectId("").SubTreeSize(), scale,
+    BaseT::ForEachInIntervalAndScale(f, 0, static_cast<int64_t>((1ULL << 63) - 1), scale,
                                      m2::RectD::GetInfiniteRect());
   }
 };
diff --git a/indexer/interval_index.hpp b/indexer/interval_index.hpp
index 61d7b330bb..53faf3c590 100644
--- a/indexer/interval_index.hpp
+++ b/indexer/interval_index.hpp
@@ -66,8 +66,12 @@ public:
   {
     if (m_Header.m_Levels != 0 && beg != end)
     {
-      ASSERT_LESS_OR_EQUAL(beg, KeyEnd(), (end));
-      ASSERT_LESS_OR_EQUAL(end, KeyEnd(), (beg));
+      // ASSERT_LESS_OR_EQUAL(beg, KeyEnd(), (end));
+      // ASSERT_LESS_OR_EQUAL(end, KeyEnd(), (beg));
+      if (beg > KeyEnd())
+        beg = KeyEnd();
+      if (end > KeyEnd())
+        end = KeyEnd();
       --end;  // end is inclusive in ForEachImpl().
       ForEachNode(f, beg, end, m_Header.m_Levels, 0,
                   m_LevelOffsets[m_Header.m_Levels + 1] - m_LevelOffsets[m_Header.m_Levels]);
diff --git a/indexer/scale_index_builder.hpp b/indexer/scale_index_builder.hpp
index 075719f1e2..87a3b219d7 100644
--- a/indexer/scale_index_builder.hpp
+++ b/indexer/scale_index_builder.hpp
@@ -69,7 +69,7 @@ public:
   {
     if (FeatureShouldBeIndexed(f))
     {
-      vector<int64_t> const cells = covering::CoverFeature(f, 250);
+      vector<int64_t> const cells = covering::CoverFeature(f, RectId::DEPTH_LEVELS, 250);
       for (vector<int64_t>::const_iterator it = cells.begin(); it != cells.end(); ++it)
         m_Sorter.Add(CellFeaturePair(*it, offset));
       ++m_NumFeatures;