diff --git a/data/minsk-pass.mwm b/data/minsk-pass.mwm
index a8119b134e..9c9b10ce17 100644
Binary files a/data/minsk-pass.mwm and b/data/minsk-pass.mwm differ
diff --git a/indexer/covering.cpp b/indexer/covering.cpp
index afe5da69d1..e113e074d7 100644
--- a/indexer/covering.cpp
+++ b/indexer/covering.cpp
@@ -68,7 +68,7 @@ namespace
   };
 }
 
-vector<int64_t> covering::CoverFeature(FeatureGeom const & feature, int level)
+vector<int64_t> covering::CoverFeature(FeatureType const & feature, int level)
 {
   vector<CoordPointT> geometry;
   feature.ForEachPoint(MakeBackInsertFunctor(geometry), level);
diff --git a/indexer/covering.hpp b/indexer/covering.hpp
index 9cc0b5a781..54452194c8 100644
--- a/indexer/covering.hpp
+++ b/indexer/covering.hpp
@@ -7,12 +7,12 @@
 #include "../std/utility.hpp"
 #include "../std/vector.hpp"
 
-class FeatureGeom;
+class FeatureType;
 
 namespace covering
 {
   // Cover feature with RectIds and return their integer representations.
-  vector<int64_t> CoverFeature(FeatureGeom const & feature, int level);
+  vector<int64_t> CoverFeature(FeatureType const & feature, int level);
   // Cover viewport with RectIds and append their RectIds as well.
   vector<pair<int64_t, int64_t> > CoverViewportAndAppendLowerLevels(m2::RectD const & rect);
   // Given a vector of intervals [a, b), sort them and merge overlapping intervals.
diff --git a/indexer/feature.cpp b/indexer/feature.cpp
index 4c4c9803fc..9efed8e853 100644
--- a/indexer/feature.cpp
+++ b/indexer/feature.cpp
@@ -14,68 +14,65 @@
 #include "../base/start_mem_debug.hpp"
 
 
-namespace pts
-{
-  inline m2::PointD ToPoint(int64_t i)
-  {
-    CoordPointT const pt = Int64ToPoint(i);
-    return m2::PointD(pt.first, pt.second);
-  }
-
-  struct Fpt2id
-  {
-    int64_t operator() (m2::PointD const & p) const
-    {
-      return PointToInt64(p.x, p.y);
-    }
-  };
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// FeatureBuilderGeom implementation
+// FeatureBuilder1 implementation
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-FeatureBuilderGeom::FeatureBuilderGeom() : m_Layer(0)
+FeatureBuilder1::FeatureBuilder1()
+: m_Layer(0), m_bArea(false), m_bHasCenter(false)
 {
 }
 
-bool FeatureBuilderGeom::IsGeometryClosed() const
+bool FeatureBuilder1::IsGeometryClosed() const
 {
   return !m_Geometry.empty() && m_Geometry.front() == m_Geometry.back();
 }
 
-void FeatureBuilderGeom::AddPoint(m2::PointD const & p)
+void FeatureBuilder1::SetCenter(m2::PointD const & p)
+{
+  m_Center = p;
+  m_bHasCenter = true;
+  m_LimitRect.Add(p);
+}
+
+void FeatureBuilder1::AddPoint(m2::PointD const & p)
 {
   m_Geometry.push_back(p);
   m_LimitRect.Add(p);
 }
 
-void FeatureBuilderGeom::AddTriangle(m2::PointD const & a, m2::PointD const & b, m2::PointD const & c)
+void FeatureBuilder1::SetAreaAddHoles(list<vector<m2::PointD> > & holes)
 {
-  pts::Fpt2id fn;
-  m_Triangles.push_back(fn(a));
-  m_Triangles.push_back(fn(b));
-  m_Triangles.push_back(fn(c));
+  m_bArea = true;
+
+  m_Holes.swap(holes);
+
+  for (list<points_t>::iterator i = m_Holes.begin(); i != m_Holes.end();)
+  {
+    if (i->size() < 3)
+      i = m_Holes.erase(i);
+    else
+      ++i;
+  }
 }
 
-void FeatureBuilderGeom::AddName(string const & name)
+void FeatureBuilder1::AddName(string const & name)
 {
-  CHECK_EQUAL(m_Name, "", (name));
   m_Name = name;
 }
 
-void FeatureBuilderGeom::AddLayer(int32_t layer)
+void FeatureBuilder1::AddLayer(int32_t layer)
 {
-  CHECK_EQUAL(m_Layer, 0, (layer));
-
   int const bound = 10;
   if (layer < -bound) layer = -bound;
   else if (layer > bound) layer = bound;
   m_Layer = layer;
 }
 
-FeatureBase FeatureBuilderGeom::GetFeatureBase() const
+FeatureBase FeatureBuilder1::GetFeatureBase() const
 {
+  CHECK ( CheckValid(), () );
+
   FeatureBase f;
   f.SetHeader(GetHeader());
 
@@ -97,6 +94,12 @@ namespace
     //return my::AlmostEqual(d1, d2, 100000000);
     return (fabs(d1 - d2) < MercatorBounds::GetCellID2PointAbsEpsilon());
   }
+
+  bool is_equal(m2::PointD const & p1, m2::PointD const & p2)
+  {
+    return p1.EqualDxDy(p2, MercatorBounds::GetCellID2PointAbsEpsilon());
+  }
+
   bool is_equal(m2::RectD const & r1, m2::RectD const & r2)
   {
     return (is_equal(r1.minX(), r2.minX()) &&
@@ -104,121 +107,200 @@ namespace
             is_equal(r1.maxX(), r2.maxX()) &&
             is_equal(r1.maxY(), r2.maxY()));
   }
-}
 
-bool FeatureBuilderGeom::operator == (FeatureBuilderGeom const & fb) const
-{
-  if (m_Geometry.size() != fb.m_Geometry.size())
-    return false;
-
-  double const eps = MercatorBounds::GetCellID2PointAbsEpsilon();
-  for (size_t i = 0; i < m_Geometry.size(); ++i)
-    if (!m_Geometry[i].EqualDxDy(fb.m_Geometry[i], eps))
+  bool is_equal(vector<m2::PointD> const & v1, vector<m2::PointD> const & v2)
+  {
+    if (v1.size() != v2.size())
       return false;
 
-  return
-      m_Types == fb.m_Types &&
-      m_Layer == fb.m_Layer &&
-      m_Name == fb.m_Name &&
-      m_Triangles == fb.m_Triangles &&
-      is_equal(m_LimitRect, fb.m_LimitRect);
+    for (size_t i = 0; i < v1.size(); ++i)
+      if (!is_equal(v1[i], v2[i]))
+        return false;
+
+    return true;
+  }
 }
 
-uint8_t FeatureBuilderGeom::GetHeader() const
+bool FeatureBuilder1::operator == (FeatureBuilder1 const & fb) const
+{
+  if (m_Types != fb.m_Types ||
+      m_Layer != fb.m_Layer ||
+      m_Name != fb.m_Name ||
+      m_bHasCenter != fb.m_bHasCenter ||
+      m_bArea != fb.m_bArea)
+  {
+    return false;
+  }
+
+  if (m_bHasCenter && !is_equal(m_Center, fb.m_Center))
+    return false;
+
+  if (!is_equal(m_LimitRect, fb.m_LimitRect))
+    return false;
+
+  if (!is_equal(m_Geometry, fb.m_Geometry))
+    return false;
+
+  if (m_Holes.size() != fb.m_Holes.size())
+    return false;
+
+  list<points_t>::const_iterator i = m_Holes.begin();
+  list<points_t>::const_iterator j = fb.m_Holes.begin();
+  for (; i != m_Holes.end(); ++i, ++j)
+    if (!is_equal(*i, *j))
+      return false;
+
+  return true;
+}
+
+bool FeatureBuilder1::CheckValid() const
+{
+  CHECK(!m_Types.empty() && m_Types.size() <= m_maxTypesCount, ());
+
+  CHECK(m_Layer >= -10 && m_Layer <= 10, ());
+
+  CHECK(m_bHasCenter || m_Geometry.size() >= 2, ());
+
+  CHECK(!m_bArea || m_Geometry.size() >= 3, ());
+
+  CHECK(m_Holes.empty() || m_bArea, ());
+
+  for (list<points_t>::const_iterator i = m_Holes.begin(); i != m_Holes.end(); ++i)
+    CHECK(i->size() >= 3, ());
+
+  return true;
+}
+
+uint8_t FeatureBuilder1::GetHeader() const
 {
   uint8_t header = static_cast<uint8_t>(m_Types.size());
-  if (m_Layer != 0)
-    header |= FeatureBase::HEADER_HAS_LAYER;
-  if (m_Geometry.size() > 1)
-  {
-    if (m_Triangles.empty())
-      header |= FeatureBase::HEADER_IS_LINE;
-    else
-      header |= FeatureBase::HEADER_IS_AREA;
-  }
+
   if (!m_Name.empty())
     header |= FeatureBase::HEADER_HAS_NAME;
+
+  if (m_Layer != 0)
+    header |= FeatureBase::HEADER_HAS_LAYER;
+
+  if (m_bHasCenter)
+    header |= FeatureBase::HEADER_HAS_POINT;
+
+  size_t const count = m_Geometry.size();
+
+  if (count > 0)
+  {
+    ASSERT ( count > 1, (count) );
+    header |= FeatureBase::HEADER_IS_LINE;
+
+    if (m_bArea)
+    {
+      ASSERT ( count > 2, (count) );
+      header |= FeatureBase::HEADER_IS_AREA;
+    }
+  }
+
   return header;
 }
 
-void FeatureBuilderGeom::SerializeBase(buffer_t & data) const
+void FeatureBuilder1::SerializeBase(buffer_t & data) const
 {
-  CHECK(!m_Geometry.empty(), ());
-  CHECK(m_Geometry.size() > 1 || m_Triangles.empty(), ());
-  CHECK_LESS(m_Types.size(), 16, ());
+  CHECK ( CheckValid(), () );
 
   PushBackByteSink<buffer_t> sink(data);
 
-  // Serialize header.
   WriteToSink(sink, GetHeader());
 
-  // Serialize types.
-  {
-    for (size_t i = 0; i < m_Types.size(); ++i)
-      WriteVarUint(sink, m_Types[i]);
-  }
+  for (size_t i = 0; i < m_Types.size(); ++i)
+    WriteVarUint(sink, m_Types[i]);
 
-  // Serialize layer.
   if (m_Layer != 0)
     WriteVarInt(sink, m_Layer);
 
-  // Serialize name.
   if (!m_Name.empty())
   {
     WriteVarUint(sink, m_Name.size() - 1);
     sink.Write(&m_Name[0], m_Name.size());
   }
+
+  if (m_bHasCenter)
+    WriteVarInt(sink, feature::pts::FromPoint(m_Center));
 }
 
-void FeatureBuilderGeom::Serialize(buffers_holder_t & data) const
+void FeatureBuilder1::Serialize(buffer_t & data) const
 {
   data.clear();
 
   SerializeBase(data);
-  SerializePoints(data);
-  SerializeTriangles(data);
 
-  ASSERT ( CheckCorrect(data), () );
-}
-
-void FeatureBuilderGeom::SerializeTriangles(buffer_t & data) const
-{
   PushBackByteSink<buffer_t> sink(data);
-  feature::SerializeTriangles(m_Triangles, sink);
+
+  if (!m_Geometry.empty())
+    feature::SavePoints(m_Geometry, sink);
+
+  if (m_bArea)
+  {
+    WriteVarUint(sink, uint32_t(m_Holes.size()));
+
+    for (list<points_t>::const_iterator i = m_Holes.begin(); i != m_Holes.end(); ++i)
+      feature::SavePoints(*i, sink);
+  }
+
+  // check for correct serialization
+#ifdef DEBUG
+  buffer_t tmp(data);
+  FeatureBuilder1 fb;
+  fb.Deserialize(tmp);
+  ASSERT ( fb == *this, () );
+#endif
 }
 
-void FeatureBuilderGeom::SerializePoints(buffer_t & data) const
+namespace
 {
-  PushBackByteSink<buffer_t> sink(data);
-  feature::SerializePoints(m_Geometry, sink);
+  void CalcRect(vector<m2::PointD> const & points, m2::RectD & rect)
+  {
+    for (size_t i = 0; i < points.size(); ++i)
+      rect.Add(points[i]);
+  }
 }
 
-bool FeatureBuilderGeom::CheckCorrect(vector<char> const & data) const
+void FeatureBuilder1::Deserialize(buffer_t & data)
 {
-  FeatureGeom::read_source_t src;
-  src.m_data = data;
-  FeatureGeom f(src);
+  FeatureBase f;
+  f.Deserialize(data, 0);
+  f.InitFeatureBuilder(*this);
 
-  FeatureBuilderGeom fb;
-  f.InitFeatureBuilder(fb);
+  ArrayByteSource src(f.DataPtr() + f.m_GeometryOffset);
 
-  string const s = f.DebugString();
+  FeatureBase::FeatureType const ft = f.GetFeatureType();
 
-  ASSERT_EQUAL(m_Layer, f.m_Layer, (s));
-  ASSERT_EQUAL(m_Name, f.m_Name, (s));
-  ASSERT(is_equal(m_LimitRect, f.m_LimitRect), (s));
-  ASSERT(*this == fb, (s));
+  if (ft != FeatureBase::FEATURE_TYPE_POINT)
+  {
+    feature::LoadPoints(m_Geometry, src);
 
-  return true;
+    CalcRect(m_Geometry, m_LimitRect);
+  }
+
+  if (ft == FeatureBase::FEATURE_TYPE_AREA)
+  {
+    m_bArea = true;
+
+    uint32_t const count = ReadVarUint<uint32_t>(src);
+    for (uint32_t i = 0; i < count; ++i)
+    {
+      m_Holes.push_back(points_t());
+      feature::LoadPoints(m_Holes.back(), src);
+    }
+  }
+
+  CHECK ( CheckValid(), () );
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // FeatureBuilderGeomRef implementation
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool FeatureBuilderGeomRef::IsDrawableLikeLine(int lowS, int highS) const
+bool FeatureBuilder2::IsDrawableLikeLine(int lowS, int highS) const
 {
-  if (m_Geometry.size() > 1)
+  if (!m_Geometry.empty())
   {
     FeatureBase const fb = GetFeatureBase();
 
@@ -230,45 +312,48 @@ bool FeatureBuilderGeomRef::IsDrawableLikeLine(int lowS, int highS) const
   return false;
 }
 
-void FeatureBuilderGeomRef::Serialize(buffers_holder_t & data) const
+void FeatureBuilder2::SerializeOffsets(uint32_t mask, offsets_t const & offsets, buffer_t & buffer)
+{
+  if (mask > 0)
+  {
+    PushBackByteSink<buffer_t> sink(buffer);
+
+    WriteVarUint(sink, mask);
+    for (size_t i = 0; i < offsets.size(); ++i)
+      WriteVarUint(sink, offsets[i]);
+  }
+}
+
+void FeatureBuilder2::Serialize(buffers_holder_t & data)
 {
   data.m_buffer.clear();
 
+  // make flags actual before header serialization
+  if (data.m_lineMask == 0)
+    m_Geometry.clear();
+
+  if (data.m_trgMask == 0)
+    m_bArea = false;
+
+  // header data serialization
   SerializeBase(data.m_buffer);
 
-  PushBackByteSink<buffer_t> sink(data.m_buffer);
-
-  // for point feature write geometry-point immediately
-  if (m_Geometry.size() == 1)
-  {
-    SerializePoints(data.m_buffer);
-  }
-  else
-  {
-    CHECK(data.m_mask > 0, (data.m_mask));  // feature should be visible
-
-    // serialize geometry offsets
-    WriteVarUint(sink, data.m_mask);
-
-    for (size_t i = 0; i < data.m_lineOffset.size(); ++i)
-      WriteVarUint(sink, data.m_lineOffset[i]);
-
-    for (size_t i = 0; i < data.m_trgOffset.size(); ++i)
-      WriteVarUint(sink, data.m_trgOffset[i]);
-  }
+  // geometry offsets serialization
+  SerializeOffsets(data.m_lineMask, data.m_lineOffset, data.m_buffer);
+  SerializeOffsets(data.m_trgMask, data.m_trgOffset, data.m_buffer);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // FeatureBase implementation
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-void FeatureBase::Deserialize(vector<char> & data, uint32_t offset)
+void FeatureBase::Deserialize(buffer_t & data, uint32_t offset)
 {
   m_Offset = offset;
   m_Data.swap(data);
 
-  m_LayerOffset = m_GeometryOffset = m_TrianglesOffset = m_NameOffset = 0;
-  m_bTypesParsed = m_bLayerParsed = m_bGeometryParsed = m_bTrianglesParsed = m_bNameParsed = false;
+  m_LayerOffset = m_NameOffset = m_CenterOffset = m_GeometryOffset = m_TrianglesOffset = 0;
+  m_bTypesParsed = m_bLayerParsed = m_bNameParsed = m_bCenterParsed = m_bGeometryParsed = m_bTrianglesParsed = false;
 
   m_Layer = 0;
   m_Name.clear();
@@ -327,256 +412,211 @@ void FeatureBase::ParseName() const
   }
 
   m_bNameParsed = true;
+  m_CenterOffset = CalcOffset(source);
+}
+
+void FeatureBase::ParseCenter() const
+{
+  ASSERT(!m_bCenterParsed, ());
+  if (!m_bNameParsed)
+    ParseName();
+
+  ArrayByteSource source(DataPtr() + m_CenterOffset);
+  if (Header() & HEADER_HAS_POINT)
+  {
+    m_Center = feature::pts::ToPoint(ReadVarInt<int64_t>(source));
+    m_LimitRect.Add(m_Center);
+  }
+
+  m_bCenterParsed = true;
   m_GeometryOffset = CalcOffset(source);
 }
 
+void FeatureBase::ParseAll() const
+{
+  if (!m_bCenterParsed)
+    ParseCenter();
+}
+
 string FeatureBase::DebugString() const
 {
   ASSERT(m_bNameParsed, ());
 
-  string res("Feature(");
+  string res("FEATURE: ");
   res +=  "'" + m_Name + "' ";
 
   for (size_t i = 0; i < GetTypesCount(); ++i)
     res += "Type:" + debug_print(m_Types[i]) + " ";
 
   res += "Layer:" + debug_print(m_Layer) + " ";
+
+  if (Header() & HEADER_HAS_POINT)
+    res += "Center:" + debug_print(m_Center) + " ";
+
   return res;
 }
 
-void FeatureBase::InitFeatureBuilder(FeatureBuilderGeom & fb) const
+void FeatureBase::InitFeatureBuilder(FeatureBuilder1 & fb) const
 {
-  ASSERT(m_bNameParsed, ());
+  ParseAll();
 
   fb.AddTypes(m_Types, m_Types + GetTypesCount());
   fb.AddLayer(m_Layer);
   fb.AddName(m_Name);
+
+  uint8_t const h = Header();
+
+  if (h & HEADER_HAS_POINT)
+    fb.SetCenter(m_Center);
+
+  if (h & HEADER_IS_AREA)
+    fb.SetAreaAddHoles(list<vector<m2::PointD> >());
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// FeatureGeom implementation
+// FeatureType implementation
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-FeatureGeom::FeatureGeom(read_source_t & src)
+FeatureType::FeatureType(read_source_t & src)
 {
   Deserialize(src);
 }
 
-void FeatureGeom::Deserialize(read_source_t & src)
+void FeatureType::Deserialize(read_source_t & src)
 {
+  m_cont = &src.m_cont;
+
+  m_bOffsetsParsed = false;
+  m_lineOffsets.clear();
+  m_trgOffsets.clear();
+
   base_type::Deserialize(src.m_data, src.m_offset);
-
-  m_Geometry.clear();
-  m_Triangles.clear();
 }
 
-template <class TSource> 
-void FeatureGeom::ParseGeometryImpl(TSource & src) const
+uint32_t FeatureType::GetOffset(int scale, offsets_t const & offsets) const
 {
-  ASSERT(!m_bGeometryParsed, ());
-  uint32_t const geometrySize =
-    (GetFeatureType() == FEATURE_TYPE_POINT ? 1 : ReadVarUint<uint32_t>(src) + 1);
+  for (size_t i = 0; i < ARRAY_SIZE(feature::g_arrScales); ++i)
+    if (scale <= feature::g_arrScales[i])
+      return offsets[i];
 
-  m_Geometry.resize(geometrySize);
-  int64_t id = 0;
-  for (size_t i = 0; i < geometrySize; ++i)
-    m_LimitRect.Add(m_Geometry[i] = pts::ToPoint(id += ReadVarInt<int64_t>(src)));
-
-  m_bGeometryParsed = true;
+  return m_invalidOffset;
 }
 
-void FeatureGeom::ParseGeometry(int) const
+namespace
 {
-  if (!m_bNameParsed)
-    ParseName();
-
-  ArrayByteSource source(DataPtr() + m_GeometryOffset);
-  ParseGeometryImpl(source);
-
-  m_TrianglesOffset = CalcOffset(source);
-}
-
-template <class TSource> 
-void FeatureGeom::ParseTrianglesImpl(TSource & src) const
-{
-  ASSERT(!m_bTrianglesParsed, ());
-  if (GetFeatureType() == FEATURE_TYPE_AREA)
+  void Points2String(string & s, vector<m2::PointD> const & points)
   {
-    uint32_t const trgPoints = (ReadVarUint<uint32_t>(src) + 1) * 3;
-    m_Triangles.resize(trgPoints);
-    int64_t id = 0;
-    for (size_t i = 0; i < trgPoints; ++i)
-      m_Triangles[i] = pts::ToPoint(id += ReadVarInt<int64_t>(src));
+    for (size_t i = 0; i < points.size(); ++i)
+      s += debug_print(points[i]) + " ";
   }
-  m_bTrianglesParsed = true;
 }
 
-void FeatureGeom::ParseTriangles(int scale) const
+string FeatureType::DebugString(int scale) const
 {
-  if (!m_bGeometryParsed)
-    ParseGeometry(scale);
+  // force to load all geometry
+  (void)GetLimitRect(scale);
 
-  ArrayByteSource source(DataPtr() + m_TrianglesOffset);
-  ParseTrianglesImpl(source);
+  string s = base_type::DebugString();
 
-  ASSERT_EQUAL ( CalcOffset(source), m_Data.size() - m_Offset, () );
+  s += "Points:";
+  Points2String(s, m_Geometry);
+
+  s += "Triangles:";
+  Points2String(s, m_Triangles);
+
+  return s;
 }
 
-void FeatureGeom::ParseAll(int scale) const
+m2::RectD FeatureType::GetLimitRect(int scale) const
 {
   if (!m_bGeometryParsed)
     ParseGeometry(scale);
 
   if (!m_bTrianglesParsed)
     ParseTriangles(scale);
-}
 
-string FeatureGeom::DebugString(int scale) const
-{
-  ParseAll(scale);
-  string res = base_type::DebugString();
-  res += debug_print(m_Geometry) + " ";
-  res += debug_print(m_Triangles) + ")";
-  return res;
-}
-
-string FeatureGeom::DebugString() const
-{
-  string ret = DebugString(m_defScale);
-  ASSERT ( !ret.empty(), () );
-  return ret;
-}
-
-void FeatureGeom::InitFeatureBuilder(FeatureBuilderGeom & fb) const
-{
-  ParseAll(m_defScale);
-  base_type::InitFeatureBuilder(fb);
-
-  for (size_t i = 0; i < m_Geometry.size(); ++i)
-    fb.AddPoint(m_Geometry[i]);
-
-  ASSERT_EQUAL(m_Triangles.size() % 3, 0, ());
-  uint32_t const triangleCount = m_Triangles.size() / 3;
-  for (size_t i = 0; i < triangleCount; ++i)
-    fb.AddTriangle(m_Triangles[3*i + 0], m_Triangles[3*i + 1], m_Triangles[3*i + 2]);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// FeatureGeomRef implementation
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-FeatureGeomRef::FeatureGeomRef(read_source_t & src)
- : base_type(src), m_cont(&src.m_cont)
-{
-}
-
-void FeatureGeomRef::Deserialize(read_source_t & src)
-{
-  m_cont = &src.m_cont;
-
-  m_bOffsetsParsed = false;
-  m_mask = 0;
-  m_gOffsets.clear();
-
-  base_type::Deserialize(src);
-}
-
-uint32_t FeatureGeomRef::GetOffset(int scale) const
-{
-  for (size_t i = 0; i < ARRAY_SIZE(feature::g_arrScales); ++i)
-    if (scale <= feature::g_arrScales[i])
-      return m_gOffsets[i];
-
-  return m_invalidOffset;
-}
-
-string FeatureGeomRef::DebugString(int scale) const
-{
-  if (!m_bOffsetsParsed)
-    ParseOffsets();
-
-  if (!m_bGeometryParsed && GetOffset(scale) == m_invalidOffset)
-    return string();
-  else
-    return base_type::DebugString(scale);
-}
-
-namespace 
-{
-  inline string get_tag(char const * prefix, int scale)
+  if (m_Triangles.empty() && m_Geometry.empty() && (Header() & HEADER_HAS_POINT) == 0)
   {
-    string str;
-    str.reserve(strlen(prefix) + 1);
-    str = prefix;
-
-    static char arrChar[] = { '0', '1', '2', '3', '4', '5' };
-    for (size_t i = 0; i < ARRAY_SIZE(feature::g_arrScales); ++i)
-      if (scale <= feature::g_arrScales[i])
-      {
-        str += arrChar[i];
-        break;
-      }
-
-    return str;
+    // This function is called during indexing, when we need
+    // to check visibility according to feature sizes.
+    // So, if no geometry for this scale, assume tha rect has zero dimensions.
+    m_LimitRect = m2::RectD(0, 0, 0, 0);
   }
+
+  return m_LimitRect;
 }
 
-void FeatureGeomRef::ParseGeometry(int scale) const
+void FeatureType::ParseGeometry(int scale) const
 {
   if (!m_bOffsetsParsed)
     ParseOffsets();
 
-  if (m_bGeometryParsed)
-    return;
-
-  ReaderSource<FileReader> source(m_cont->GetReader(get_tag(GEOMETRY_FILE_TAG, scale)));
-  uint32_t const offset = GetOffset(scale);
-  CHECK ( offset != m_invalidOffset, (offset) );
-  source.Skip(offset);
-
-  ParseGeometryImpl(source);
-}
-
-void FeatureGeomRef::ParseTriangles(int scale) const
-{
-  if (!m_bOffsetsParsed)
-    ParseOffsets();
-
-  ReaderSource<FileReader> source(m_cont->GetReader(get_tag(TRIANGLE_FILE_TAG, 0)));
-  source.Skip(m_trgOffset);
-
-  ParseTrianglesImpl(source);
-}
-
-void FeatureGeomRef::ParseOffsets() const
-{
-  if (!m_bNameParsed)
-    ParseName();
-
-  ArrayByteSource source(DataPtr() + m_GeometryOffset);
-  FeatureType const type = GetFeatureType();
-
-  if (type == FEATURE_TYPE_POINT)
+  if (Header() & HEADER_IS_LINE)
   {
-    ParseGeometryImpl(source);
-  }
-  else
-  {
-    uint32_t mask = m_mask = ReadVarUint<uint32_t>(source);
-    ASSERT ( mask > 0, () );
-    while (mask > 0)
+    uint32_t const offset = GetOffset(scale, m_lineOffsets);
+    if (offset != m_invalidOffset)
     {
-      if (mask & 0x01)
-        m_gOffsets.push_back(ReadVarUint<uint32_t>(source));
-      else
-        m_gOffsets.push_back((uint32_t)m_invalidOffset);
+      ReaderSource<FileReader> src(m_cont->GetReader(feature::GetTagForScale(GEOMETRY_FILE_TAG, scale)));
+      src.Skip(offset);
+      feature::LoadPoints(m_Geometry, src);
 
-      mask = mask >> 1;
+      CalcRect(m_Geometry, m_LimitRect);
     }
-
-    if (type == FEATURE_TYPE_AREA)
-      m_trgOffset = ReadVarUint<uint32_t>(source);
   }
 
+  m_bGeometryParsed = true;
+}
+
+void FeatureType::ParseTriangles(int scale) const
+{
+  if (!m_bOffsetsParsed)
+    ParseOffsets();
+
+  if (Header() & HEADER_IS_AREA)
+  {
+    uint32_t const offset = GetOffset(scale, m_trgOffsets);
+    if (offset != m_invalidOffset)
+    {
+      ReaderSource<FileReader> src(m_cont->GetReader(feature::GetTagForScale(TRIANGLE_FILE_TAG, scale)));
+      src.Skip(offset);
+      feature::LoadTriangles(m_Triangles, src);
+
+      CalcRect(m_Triangles, m_LimitRect);
+    }
+  }
+
+  m_bTrianglesParsed = true;
+}
+
+void FeatureType::ReadOffsetsImpl(ArrayByteSource & src, offsets_t & offsets)
+{
+  uint32_t mask = ReadVarUint<uint32_t>(src);
+  ASSERT ( mask > 0, () );
+  while (mask > 0)
+  {
+    if (mask & 0x01)
+      offsets.push_back(ReadVarUint<uint32_t>(src));
+    else
+      offsets.push_back((uint32_t)m_invalidOffset);
+
+    mask = mask >> 1;
+  }
+}
+
+void FeatureType::ParseOffsets() const
+{
+  if (!m_bCenterParsed)
+    ParseCenter();
+
+  ArrayByteSource src(DataPtr() + m_GeometryOffset);
+
+  uint8_t const h = Header();
+
+  if (h & HEADER_IS_LINE)
+    ReadOffsetsImpl(src, m_lineOffsets);
+
+  if (h & HEADER_IS_AREA)
+    ReadOffsetsImpl(src, m_trgOffsets);
+
   m_bOffsetsParsed = true;
 }
diff --git a/indexer/feature.hpp b/indexer/feature.hpp
index 75c3d2facf..89b042d0fd 100644
--- a/indexer/feature.hpp
+++ b/indexer/feature.hpp
@@ -18,20 +18,32 @@
 class ArrayByteSource;
 class FeatureBase;
 
-class FeatureBuilderGeom
+/// Used for serialization\deserialization of features during --generate_features.
+class FeatureBuilder1
 {
 public:
-  FeatureBuilderGeom();
+  FeatureBuilder1();
+
+  /// @name Geometry manipulating functions.
+  //@{
+  /// Set center (origin) point of feature.
+  void SetCenter(m2::PointD const & p);
+
+  /// Add point to geometry.
+  void AddPoint(m2::PointD const & p);
+
+  /// Set that featue is area and get ownership of holes.
+  void SetAreaAddHoles(list<vector<m2::PointD> > & holes);
+  //@}
 
   void AddName(string const & name);
-  void AddPoint(m2::PointD const & p);
-  void AddTriangle(m2::PointD const & a, m2::PointD const & b, m2::PointD const & c);
+
+  static const int m_maxTypesCount = 7;
 
   template <class TIter>
   inline void AddTypes(TIter beg, TIter end)
   {
-    // 15 - is the maximum count of types (@see Feature::GetTypesCount())
-    size_t const count = min(15, static_cast<int>(distance(beg, end)));
+    int const count = min(m_maxTypesCount, static_cast<int>(distance(beg, end)));
     m_Types.assign(beg, beg + count);
   }
   inline void SetType(uint32_t type)
@@ -43,71 +55,113 @@ public:
   void AddLayer(int32_t layer);
 
   typedef vector<char> buffer_t;
-  typedef buffer_t buffers_holder_t;
-  void Serialize(buffers_holder_t & data) const;
 
+  /// @name Serialization.
+  //@{
+  void Serialize(buffer_t & data) const;
+  void SerializeBase(buffer_t & data) const;
+
+  void Deserialize(buffer_t & data);
+  //@}
+
+  ///@name Selectors.
+  //@{
   inline m2::RectD GetLimitRect() const { return m_LimitRect; }
 
-  // Get common parameters of feature.
+  /// Get common parameters of feature.
   FeatureBase GetFeatureBase() const;
 
   bool IsGeometryClosed() const;
-  size_t GetPointsCount() const { return m_Geometry.size(); }
 
-  bool operator == (FeatureBuilderGeom const &) const;
+  inline size_t GetPointsCount() const { return m_Geometry.size(); }
+
+  template <class ToDo>
+  void ForEachPointRef(ToDo & toDo) const
+  {
+    for_each(m_Geometry.begin(), m_Geometry.end(), bind<void>(ref(toDo), _1));
+  }
+  //@}
 
 protected:
-  typedef vector<m2::PointD> points_t;
 
-  void SerializeBase(buffer_t & data) const;
-  void SerializePoints(buffer_t & data) const;
-  void SerializeTriangles(buffer_t & data) const;
+  /// @name For diagnostic use only.
+  //@{
+  bool operator == (FeatureBuilder1 const &) const;
+
+  bool CheckValid() const;
+  //@}
+
+  typedef vector<m2::PointD> points_t;
 
   uint8_t GetHeader() const;
 
-  bool CheckCorrect(vector<char> const & data) const;
-
-  int32_t m_Layer;
+  /// Name. Can be empty. Check HEADER_HAS_NAME.
   string m_Name;
+
+  /// Feature classificator-types. Can not be empty.
   vector<uint32_t> m_Types;
 
+  /// Drawable layer of feature. Can be empty, Check HEADER_HAS_LAYER.
+  int32_t m_Layer;
+
   m2::RectD m_LimitRect;
 
-  points_t m_Geometry;  // store points as is for further processing
+  /// Can be one of the following:
+  /// - point in point-feature
+  /// - origin point of text [future] in line-feature
+  /// - origin point of text or symbol in area-feature
+  m2::PointD m_Center;    // Check  HEADER_HAS_POINT
 
-  vector<int64_t> m_Triangles;
+  /// Can be one of the following:
+  /// - geometry in line-feature
+  /// - boundary in area-feature
+  points_t m_Geometry;    // Check HEADER_IS_LINE
+
+  /// List of holes in area-feature.
+  list<points_t> m_Holes; // Check HEADER_IS_AREA
+
+  bool m_bArea;       ///< this is area-feature
+  bool m_bHasCenter;  ///< m_center exists
 };
 
-class FeatureBuilderGeomRef : public FeatureBuilderGeom
+/// Used for serialization of features during final pass.
+class FeatureBuilder2 : public FeatureBuilder1
 {
-  typedef FeatureBuilderGeom base_type;
+  typedef FeatureBuilder1 base_type;
+
+  typedef vector<uint32_t> offsets_t;
+
+  static void SerializeOffsets(uint32_t mask, offsets_t const & offsets, buffer_t & buffer);
 
 public:
 
   struct buffers_holder_t
   {
-    vector<uint32_t> m_lineOffset;  // in
-    vector<uint32_t> m_trgOffset;   // in
-    uint32_t m_mask;
+    offsets_t m_lineOffset;  // in
+    offsets_t m_trgOffset;   // in
+    uint32_t m_lineMask, m_trgMask;
 
     base_type::buffer_t m_buffer;   // out
 
-    buffers_holder_t() : m_mask(0) {}
+    buffers_holder_t() : m_lineMask(0), m_trgMask(0) {}
   };
 
   bool IsDrawableLikeLine(int lowS, int highS) const;
+  bool IsDrawableLikeArea() const { return m_bArea; }
 
   points_t const & GetGeometry() const { return m_Geometry; }
-  vector<int64_t> const & GetTriangles() const { return m_Triangles; }
+  list<points_t> const & GetHoles() const { return m_Holes; }
 
   /// @name Overwrite from base_type.
   //@{
-  void Serialize(buffers_holder_t & data) const;
+  void Serialize(buffers_holder_t & data);
   //@}
 };
 
+/// Base feature class for storing common data (without geometry).
 class FeatureBase
 {
+  static const int m_maxTypesCount = 7;
 public:
   enum FeatureType
   {
@@ -119,22 +173,25 @@ public:
 
   FeatureBase() : m_Offset(0) {}
 
-  /// @name Use like polymorfic functions. Need to overwrite in derived classes.
-  //@{
-  void Deserialize(vector<char> & data, uint32_t offset = 0);
-  string DebugString() const;
-  void InitFeatureBuilder(FeatureBuilderGeom & fb) const;
-  //@}
+  typedef vector<char> buffer_t;
 
   inline FeatureType GetFeatureType() const
   {
-    ASSERT_NOT_EQUAL((Header() >> 4) & 3, 3, (DebugString()));
-    return static_cast<FeatureType>((Header() >> 4) & 3);
+    uint8_t const h = Header();
+    if (h & HEADER_IS_AREA)
+      return FEATURE_TYPE_AREA;
+    else if (h & HEADER_IS_LINE)
+      return FEATURE_TYPE_LINE;
+    else
+    {
+      ASSERT ( h & HEADER_HAS_POINT, () );
+      return FEATURE_TYPE_POINT;
+    }
   }
 
   inline uint32_t GetTypesCount() const
   {
-    return Header() & 0xF;
+    return Header() & m_maxTypesCount;
   }
 
   inline int32_t GetLayer() const
@@ -157,7 +214,7 @@ public:
 
   inline m2::RectD GetLimitRect() const
   {
-    ASSERT(m_bGeometryParsed, ());
+    ASSERT ( m_bGeometryParsed || m_bTrianglesParsed, () );
     return m_LimitRect;
   }
 
@@ -166,7 +223,7 @@ public:
   public:
     vector<uint32_t> m_types;
 
-    GetTypesFn() { m_types.reserve(16); }
+    GetTypesFn() { m_types.reserve(m_maxTypesCount); }
     void operator() (uint32_t t)
     {
       m_types.push_back(t);
@@ -178,6 +235,7 @@ public:
   {
     if (!m_bTypesParsed)
       ParseTypes();
+
     uint32_t const typeCount = GetTypesCount();
     for (size_t i = 0; i < typeCount; ++i)
       f(m_Types[i]);
@@ -188,14 +246,22 @@ public:
     HEADER_HAS_LAYER = 1U << 7,
     HEADER_HAS_NAME = 1U << 6,
     HEADER_IS_AREA = 1U << 5,
-    HEADER_IS_LINE = 1U << 4
+    HEADER_IS_LINE = 1U << 4,
+    HEADER_HAS_POINT = 1U << 3
   };
 
+  void InitFeatureBuilder(FeatureBuilder1 & fb) const;
+
 protected:
-  vector<char> m_Data;
+  void Deserialize(buffer_t & data, uint32_t offset = 0);
+  string DebugString() const;
+
+protected:
+
+  buffer_t m_Data;
   uint32_t m_Offset;
 
-  friend class FeatureBuilderGeom;
+  friend class FeatureBuilder1;
 
   void SetHeader(uint8_t h);
 
@@ -203,39 +269,48 @@ protected:
   inline uint8_t Header() const { return static_cast<uint8_t>(*DataPtr()); }
   uint32_t CalcOffset(ArrayByteSource const & source) const;
 
-  mutable uint32_t m_Types[16];
+  mutable uint32_t m_Types[m_maxTypesCount];
   mutable int32_t m_Layer;
   mutable string m_Name;
+  mutable m2::PointD m_Center;
 
   mutable m2::RectD m_LimitRect;
 
   mutable uint32_t m_LayerOffset;
   mutable uint32_t m_NameOffset;
+  mutable uint32_t m_CenterOffset;
   mutable uint32_t m_GeometryOffset;
   mutable uint32_t m_TrianglesOffset;
 
   mutable bool m_bTypesParsed;
   mutable bool m_bLayerParsed;
   mutable bool m_bNameParsed;
+  mutable bool m_bCenterParsed;
   mutable bool m_bGeometryParsed;
   mutable bool m_bTrianglesParsed;
 
   void ParseTypes() const;
   void ParseLayer() const;
   void ParseName() const;
+  void ParseCenter() const;
+
+  void ParseAll() const;
 };
 
-class FeatureGeom : public FeatureBase
+/// Working feature class with geometry.
+class FeatureType : public FeatureBase
 {
   typedef FeatureBase base_type;
 
 public:
   struct read_source_t
   {
-    vector<char> m_data;
+    buffer_t m_data;
     uint32_t m_offset;
 
-    read_source_t() : m_offset(0) {}
+    FilesContainerR m_cont;
+
+    read_source_t(FilesContainerR const & cont) : m_offset(0), m_cont(cont) {}
 
     void assign(char const * data, uint32_t size)
     {
@@ -243,53 +318,30 @@ public:
     }
   };
 
-  FeatureGeom() {}
-  FeatureGeom(read_source_t & src);
+  FeatureType() {}
+  FeatureType(read_source_t & src);
 
-  /// @name Overwrite from base_type.
-  //@{
   void Deserialize(read_source_t & src);
-  string DebugString() const;
-  void InitFeatureBuilder(FeatureBuilderGeom & fb) const;
-  //@}
 
-  inline m2::RectD GetLimitRect() const
-  {
-    if (!m_bGeometryParsed)
-    {
-      // this function use only in index generation,
-      // so get geometry for upper scale
-      ParseGeometry(m_defScale);
-    }
-    return base_type::GetLimitRect();
-  }
-
-  /// @name Used only in unit-tests. So remove it.
+  /// @name Geometry.
   //@{
-  //inline uint32_t GetGeometrySize() const
-  //{
-  //  if (!m_bGeometryParsed)
-  //    ParseGeometry();
-  //  return m_Geometry.size();
-  //}
-
-  //inline uint32_t GetTriangleCount() const
-  //{
-  //  if (!m_bTrianglesParsed)
-  //    ParseTriangles();
-  //  return (m_Triangles.size() / 3);
-  //}
-  //@}
-
-  static int const m_defScale = 17;
+  m2::RectD GetLimitRect(int scale) const;
 
   template <typename FunctorT>
   void ForEachPointRef(FunctorT & f, int scale) const
   {
     if (!m_bGeometryParsed)
       ParseGeometry(scale);
-    for (size_t i = 0; i < m_Geometry.size(); ++i)
-      f(CoordPointT(m_Geometry[i].x, m_Geometry[i].y));
+
+    if (m_Geometry.empty())
+    {
+      f(CoordPointT(m_Center.x, m_Center.y));
+    }
+    else
+    {
+      for (size_t i = 0; i < m_Geometry.size(); ++i)
+        f(CoordPointT(m_Geometry[i].x, m_Geometry[i].y));
+    }
   }
 
   template <typename FunctorT>
@@ -303,6 +355,7 @@ public:
   {
     if (!m_bTrianglesParsed)
       ParseTriangles(scale);
+
     for (size_t i = 0; i < m_Triangles.size();)
     {
       f(m_Triangles[i], m_Triangles[i+1], m_Triangles[i+2]);
@@ -317,64 +370,30 @@ public:
     ForEachTriangleRef(f, scale);
     f.EndPrimitive();
   }
+  //@}
 
-protected:
-  template <class TSource> void ParseGeometryImpl(TSource & src) const;
-  template <class TSource> void ParseTrianglesImpl(TSource & src) const;
+  /// For test cases only.
+  string DebugString(int scale) const;
 
-  virtual string DebugString(int scale) const;
-  virtual void ParseGeometry(int scale) const;
-  virtual void ParseTriangles(int scale) const;
-
-  void ParseAll(int scale) const;
+private:
+  void ParseOffsets() const;
+  void ParseGeometry(int scale) const;
+  void ParseTriangles(int scale) const;
 
   mutable vector<m2::PointD> m_Geometry;
   mutable vector<m2::PointD> m_Triangles;
-};
 
-class FeatureGeomRef : public FeatureGeom
-{
-  typedef FeatureGeom base_type;
-
-public:
-  struct read_source_t : public base_type::read_source_t
-  {
-    FilesContainerR m_cont;
-    read_source_t(FilesContainerR const & cont) : m_cont(cont) {}
-  };
-
-  FeatureGeomRef() {}
-  FeatureGeomRef(read_source_t & src);
-
-  void Deserialize(read_source_t & src);
-
-  /// @name Overwrite from base_type.
-  //@{
-  virtual string DebugString(int scale) const;
-protected:
-  virtual void ParseGeometry(int scale) const;
-  virtual void ParseTriangles(int scale) const;
-  //@}
-
-private:
   FilesContainerR * m_cont;
 
-  void ParseOffsets() const;
   mutable bool m_bOffsetsParsed;
 
+  typedef vector<uint32_t> offsets_t;
+
+  static void ReadOffsetsImpl(ArrayByteSource & src, offsets_t & offsets);
+
   static uint32_t const m_invalidOffset = uint32_t(-1);
 
-  uint32_t GetOffset(int scale) const;
+  uint32_t GetOffset(int scale, offsets_t const & offset) const;
 
-  mutable uint32_t m_mask;
-  mutable vector<uint32_t> m_gOffsets;
-  mutable uint32_t m_trgOffset;
+  mutable offsets_t m_lineOffsets, m_trgOffsets;
 };
-
-inline string debug_print(FeatureGeom const & f)
-{
-  return f.DebugString();
-}
-
-typedef FeatureGeomRef FeatureType;
-typedef FeatureBuilderGeomRef FeatureBuilderType;
diff --git a/indexer/feature_impl.hpp b/indexer/feature_impl.hpp
index 8f7a914ec1..4177719b66 100644
--- a/indexer/feature_impl.hpp
+++ b/indexer/feature_impl.hpp
@@ -9,50 +9,110 @@
 
 namespace feature
 {
+  namespace pts
+  {
+    inline int64_t FromPoint(m2::PointD const & p)
+    {
+      return PointToInt64(p.x, p.y);
+    }
+
+    inline m2::PointD ToPoint(int64_t i)
+    {
+      CoordPointT const pt = Int64ToPoint(i);
+      return m2::PointD(pt.first, pt.second);
+    }
+  }
+
   namespace detail
   {
-    struct pt_2_id
+    inline void TransformPoints(vector<m2::PointD> const & points, vector<int64_t> & cells)
     {
-      int64_t operator() (m2::PointD const & p) const
-      {
-        return PointToInt64(p.x, p.y);
-      }
-    };
-  }
-
-  template <class TSink>
-  void SerializePoints(vector<m2::PointD> const & points, TSink & sink)
-  {
-    uint32_t const ptsCount = points.size();
-    ASSERT_GREATER_OR_EQUAL(ptsCount, 1, ());
-
-    vector<int64_t> geom;
-    geom.reserve(ptsCount);
-    transform(points.begin(), points.end(), back_inserter(geom), detail::pt_2_id());
-
-    if (ptsCount == 1)
-    {
-      WriteVarInt(sink, geom[0]);
+      cells.reserve(points.size());
+      transform(points.begin(), points.end(), back_inserter(cells), &pts::FromPoint);
     }
-    else
+
+    template <class TSink>
+    void WriteCells(vector<int64_t> & cells, TSink & sink)
     {
-      WriteVarUint(sink, ptsCount - 1);
-      for (size_t i = 0; i < ptsCount; ++i)
-        WriteVarInt(sink, i == 0 ? geom[0] : geom[i] - geom[i-1]);
+      for (size_t i = 0; i < cells.size(); ++i)
+        WriteVarInt(sink, i == 0 ? cells[0] : cells[i] - cells[i-1]);
+    }
+
+    template <class TSource>
+    void ReadPoints(vector<m2::PointD> & points, TSource & src)
+    {
+      int64_t id = 0;
+      for (size_t i = 0; i < points.size(); ++i)
+        points[i] = pts::ToPoint(id += ReadVarInt<int64_t>(src));
     }
   }
 
   template <class TSink>
-  void SerializeTriangles(vector<int64_t> triangles, TSink & sink)
+  void SavePoints(vector<m2::PointD> const & points, TSink & sink)
   {
-    if (!triangles.empty())
-    {
-      ASSERT_EQUAL(triangles.size() % 3, 0, (triangles.size()));
-      WriteVarUint(sink, triangles.size() / 3 - 1);
-      for (size_t i = 0; i < triangles.size(); ++i)
-        WriteVarInt(sink, i == 0 ? triangles[i] : (triangles[i] - triangles[i-1]));
-    }
+    uint32_t const count = points.size();
+    ASSERT_GREATER(count, 1, ());
+
+    vector<int64_t> cells;
+    detail::TransformPoints(points, cells);
+
+    WriteVarUint(sink, count - 2);
+
+    detail::WriteCells(cells, sink);
   }
 
+  template <class TSource>
+  void LoadPoints(vector<m2::PointD> & points, TSource & src)
+  {
+    uint32_t const count = ReadVarUint<uint32_t>(src) + 2;
+    points.resize(count);
+
+    detail::ReadPoints(points, src);
+  }
+
+  template <class TSink>
+  void SaveTriangles(vector<m2::PointD> const & triangles, TSink & sink)
+  {
+    uint32_t const count = triangles.size();
+    ASSERT_GREATER(count, 0, ());
+    ASSERT_EQUAL(count % 3, 0, (count));
+
+    vector<int64_t> cells;
+    detail::TransformPoints(triangles, cells);
+
+    WriteVarUint(sink, count / 3 - 1);
+
+    detail::WriteCells(cells, sink);
+  }
+
+  template <class TSource>
+  void LoadTriangles(vector<m2::PointD> & points, TSource & src)
+  {
+    uint32_t const count = 3 * (ReadVarUint<uint32_t>(src) + 1);
+    points.resize(count);
+
+    detail::ReadPoints(points, src);
+  }
+
+
   static int g_arrScales[] = { 5, 10, 14, 17 };  // 17 = scales::GetUpperScale()
+
+  inline string GetTagForScale(char const * prefix, int scale)
+  {
+    string str;
+    str.reserve(strlen(prefix) + 1);
+    str = prefix;
+
+    static char arrChar[] = { '0', '1', '2', '3' };
+    STATIC_ASSERT ( ARRAY_SIZE(arrChar) == ARRAY_SIZE(g_arrScales) );
+
+    for (size_t i = 0; i < ARRAY_SIZE(feature::g_arrScales); ++i)
+      if (scale <= feature::g_arrScales[i])
+      {
+        str += arrChar[i];
+        break;
+      }
+
+    return str;
+  }
 }
diff --git a/indexer/feature_processor.hpp b/indexer/feature_processor.hpp
index e9e09fe00d..f2cbcf443a 100644
--- a/indexer/feature_processor.hpp
+++ b/indexer/feature_processor.hpp
@@ -19,11 +19,11 @@ namespace feature
 
    /// Read feature from feature source.
   template <class TSource>
-  void ReadFromSource(TSource & src, FeatureGeom & f, typename FeatureGeom::read_source_t & buffer)
+  void ReadFromSourceRowFormat(TSource & src, FeatureBuilder1 & f)
   {
     uint32_t const sz = ReadVarUint<uint32_t>(src);
-    buffer.m_data.resize(sz);
-    src.Read(&buffer.m_data[0], sz);
+    typename FeatureBuilder1::buffer_t buffer(sz);
+    src.Read(&buffer[0], sz);
     f.Deserialize(buffer);
   }
 
@@ -41,11 +41,10 @@ namespace feature
     uint64_t const fSize = reader.Size();
 
     // read features one by one
-    typename FeatureGeom::read_source_t buffer;
     while (currPos < fSize)
     {
-      FeatureGeom f;
-      ReadFromSource(src, f, buffer);
+      FeatureBuilder1 f;
+      ReadFromSourceRowFormat(src, f);
       toDo(f, currPos);
       currPos = src.Pos();
     }
diff --git a/indexer/indexer_tests/feature_bucketer_test.cpp b/indexer/indexer_tests/feature_bucketer_test.cpp
index eec9b87415..7c449dca3f 100644
--- a/indexer/indexer_tests/feature_bucketer_test.cpp
+++ b/indexer/indexer_tests/feature_bucketer_test.cpp
@@ -23,11 +23,12 @@ namespace
     {
     }
 
-    void operator() (FeatureBuilderGeom const & fb)
+    void operator() (FeatureBuilder1 const & fb)
     {
-      FeatureGeom f;
-      FeatureBuilder2Feature(fb, f);
-      m_pContainer->push_back(f.DebugString());
+      FeatureType f;
+      FeatureBuilder2Feature(
+        static_cast<FeatureBuilder2 &>(const_cast<FeatureBuilder1 &>(fb)), f);
+      m_pContainer->push_back(f.DebugString(0));
     }
 
   private:
@@ -47,14 +48,15 @@ UNIT_TEST(FeatureBucketerSmokeTest)
   map<string, vector<string> > out, expectedOut;
   FeatureBucketer bucketer(1, &out);
 
-  FeatureBuilderGeom fb;
+  FeatureBuilder2 fb;
   fb.AddPoint(m2::PointD(10, 10));
   fb.AddPoint(m2::PointD(20, 20));
+  fb.SetType(0);
   bucketer(fb);
 
-  FeatureGeom f;
+  FeatureType f;
   FeatureBuilder2Feature(fb, f);
-  expectedOut["3"].push_back(f.DebugString());
+  expectedOut["3"].push_back(f.DebugString(0));
   TEST_EQUAL(out, expectedOut, ());
 
   vector<string> bucketNames;
diff --git a/indexer/indexer_tests/feature_routine.cpp b/indexer/indexer_tests/feature_routine.cpp
index 41d258adaa..8e5ac75756 100644
--- a/indexer/indexer_tests/feature_routine.cpp
+++ b/indexer/indexer_tests/feature_routine.cpp
@@ -12,7 +12,7 @@ namespace
   class feature_source_initializer
   {
     string m_name;
-    FeatureGeomRef::read_source_t * m_source;
+    FeatureType::read_source_t * m_source;
 
   public:
     feature_source_initializer(string const & fName)
@@ -20,10 +20,10 @@ namespace
     {
     }
 
-    FeatureGeomRef::read_source_t & get_source(vector<char> & buffer)
+    FeatureType::read_source_t & get_source(vector<char> & buffer)
     {
       delete m_source;
-      m_source = new FeatureGeomRef::read_source_t(FilesContainerR(m_name));
+      m_source = new FeatureType::read_source_t(FilesContainerR(m_name));
       m_source->m_data.swap(buffer);
       return *m_source;
     }
@@ -36,14 +36,14 @@ namespace
   };
 }
 
-void FeatureBuilder2Feature(FeatureBuilderGeomRef const & fb, FeatureGeomRef & f)
+void FeatureBuilder2Feature(FeatureBuilder2 & fb, FeatureType & f)
 {
   string const datFile = "indexer_tests_tmp.dat";
 
-  FeatureBuilderGeomRef::buffers_holder_t buffers;
+  FeatureBuilder2::buffers_holder_t buffers;
   buffers.m_lineOffset.push_back(0);
   buffers.m_trgOffset.push_back(0);
-  buffers.m_mask = 1;
+  buffers.m_lineMask = 1;
   fb.Serialize(buffers);
 
   {
@@ -51,13 +51,13 @@ void FeatureBuilder2Feature(FeatureBuilderGeomRef const & fb, FeatureGeomRef & f
 
     {
       FileWriter geom = writer.GetWriter(string(GEOMETRY_FILE_TAG) + '0');
-      feature::SerializePoints(fb.GetGeometry(), geom);
+      feature::SavePoints(fb.GetGeometry(), geom);
     }
 
-    {
-      FileWriter trg = writer.GetWriter(string(TRIANGLE_FILE_TAG) + '0');
-      feature::SerializeTriangles(fb.GetTriangles(), trg);
-    }
+    //{
+    //  FileWriter trg = writer.GetWriter(string(TRIANGLE_FILE_TAG) + '0');
+    //  feature::SaveTriangles(fb.GetTriangles(), trg);
+    //}
 
     writer.Finish();
   }
@@ -66,22 +66,7 @@ void FeatureBuilder2Feature(FeatureBuilderGeomRef const & fb, FeatureGeomRef & f
   f.Deserialize(staticInstance.get_source(buffers.m_buffer));
 }
 
-void Feature2FeatureBuilder(FeatureGeomRef const & f, FeatureBuilderGeomRef & fb)
-{
-  f.InitFeatureBuilder(fb);
-}
-
-void FeatureBuilder2Feature(FeatureBuilderGeom const & fb, FeatureGeom & f)
-{
-  FeatureBuilderGeom::buffers_holder_t buffers;
-  fb.Serialize(buffers);
-
-  FeatureGeom::read_source_t source;
-  source.m_data.swap(buffers);
-  f.Deserialize(source);
-}
-
-void Feature2FeatureBuilder(FeatureGeom const & f, FeatureBuilderGeom & fb)
+void Feature2FeatureBuilder(FeatureType const & f, FeatureBuilder2 & fb)
 {
   f.InitFeatureBuilder(fb);
 }
diff --git a/indexer/indexer_tests/feature_routine.hpp b/indexer/indexer_tests/feature_routine.hpp
index 330df0e49b..2f90c80a10 100644
--- a/indexer/indexer_tests/feature_routine.hpp
+++ b/indexer/indexer_tests/feature_routine.hpp
@@ -2,8 +2,5 @@
 
 #include "../feature.hpp"
 
-void FeatureBuilder2Feature(FeatureBuilderGeomRef const & fb, FeatureGeomRef & f);
-void Feature2FeatureBuilder(FeatureGeomRef const & f, FeatureBuilderGeomRef & fb);
-
-void FeatureBuilder2Feature(FeatureBuilderGeom const & fb, FeatureGeom & f);
-void Feature2FeatureBuilder(FeatureGeom const & f, FeatureBuilderGeom & fb);
+void FeatureBuilder2Feature(FeatureBuilder2 & fb, FeatureType & f);
+void Feature2FeatureBuilder(FeatureType const & f, FeatureBuilder2 & fb);
diff --git a/indexer/indexer_tests/feature_test.cpp b/indexer/indexer_tests/feature_test.cpp
index 0718008dd3..fb1d43a678 100644
--- a/indexer/indexer_tests/feature_test.cpp
+++ b/indexer/indexer_tests/feature_test.cpp
@@ -45,10 +45,7 @@ UNIT_TEST(Feature_Deserialize)
                       platform.ReadPathForFile("classificator.txt"),
                       platform.ReadPathForFile("visibility.txt"));
 
-  vector<int> a;
-  a.push_back(1);
-  a.push_back(2);
-  FeatureBuilderType fb;
+  FeatureBuilder2 fb;
 
   fb.AddName("name");
 
@@ -62,14 +59,14 @@ UNIT_TEST(Feature_Deserialize)
       fb.AddPoint(points[i]);
   }
 
-  vector<m2::PointD> triangles;
-  {
-    triangles.push_back(m2::PointD(0.5, 0.5));
-    triangles.push_back(m2::PointD(0.25, 0.5));
-    triangles.push_back(m2::PointD(1.0, 1.0));
-    for (size_t i = 0; i < triangles.size(); i += 3)
-      fb.AddTriangle(triangles[i], triangles[i+1], triangles[i+2]);
-  }
+  //vector<m2::PointD> triangles;
+  //{
+  //  triangles.push_back(m2::PointD(0.5, 0.5));
+  //  triangles.push_back(m2::PointD(0.25, 0.5));
+  //  triangles.push_back(m2::PointD(1.0, 1.0));
+  //  for (size_t i = 0; i < triangles.size(); i += 3)
+  //    fb.AddTriangle(triangles[i], triangles[i+1], triangles[i+2]);
+  //}
 
   fb.AddLayer(3);
 
@@ -91,7 +88,7 @@ UNIT_TEST(Feature_Deserialize)
   FeatureType f;
   FeatureBuilder2Feature(fb, f);
 
-  TEST_EQUAL(f.GetFeatureType(), FeatureBase::FEATURE_TYPE_AREA, ());
+  TEST_EQUAL(f.GetFeatureType(), FeatureBase::FEATURE_TYPE_LINE, ());
 
   FeatureBase::GetTypesFn doGetTypes;
   f.ForEachTypeRef(doGetTypes);
@@ -108,22 +105,24 @@ UNIT_TEST(Feature_Deserialize)
   f.ForEachPointRef(featurePoints, level);
   TEST_EQUAL(points, featurePoints.m_V, ());
 
-  PointAccumulator featureTriangles;
-  f.ForEachTriangleRef(featureTriangles, level);
-  TEST_EQUAL(triangles, featureTriangles.m_V, ());
+  //PointAccumulator featureTriangles;
+  //f.ForEachTriangleRef(featureTriangles, level);
+  //TEST_EQUAL(triangles, featureTriangles.m_V, ());
 
   double const eps = MercatorBounds::GetCellID2PointAbsEpsilon();
-  TEST_LESS(fabs(f.GetLimitRect().minX() - 0.25), eps, ());
-  TEST_LESS(fabs(f.GetLimitRect().minY() - 0.20), eps, ());
-  TEST_LESS(fabs(f.GetLimitRect().maxX() - 1.00), eps, ());
-  TEST_LESS(fabs(f.GetLimitRect().maxY() - 1.00), eps, ());
+  m2::RectD const & rect = f.GetLimitRect(level);
 
-  {
-    FeatureBuilderType fbTest;
-    Feature2FeatureBuilder(f, fbTest);
+  TEST_LESS(fabs(rect.minX() - 0.25), eps, ());
+  TEST_LESS(fabs(rect.minY() - 0.20), eps, ());
+  TEST_LESS(fabs(rect.maxX() - 1.00), eps, ());
+  TEST_LESS(fabs(rect.maxY() - 1.00), eps, ());
 
-    FeatureType fTest;
-    FeatureBuilder2Feature(fbTest, fTest);
-    TEST_EQUAL(f.DebugString(level), fTest.DebugString(level), ());
-  }
+  //{
+  //  FeatureBuilder2 fbTest;
+  //  Feature2FeatureBuilder(f, fbTest);
+
+  //  FeatureType fTest;
+  //  FeatureBuilder2Feature(fbTest, fTest);
+  //  TEST_EQUAL(f.DebugString(level), fTest.DebugString(level), ());
+  //}
 }
diff --git a/indexer/indexer_tool/feature_bucketer.hpp b/indexer/indexer_tool/feature_bucketer.hpp
index 8f291b8716..7d7a9df703 100644
--- a/indexer/indexer_tool/feature_bucketer.hpp
+++ b/indexer/indexer_tool/feature_bucketer.hpp
@@ -104,7 +104,7 @@ private:
 class SimpleFeatureClipper
 {
 public:
-  typedef FeatureBuilderGeom feature_builder_t;
+  typedef FeatureBuilder1 feature_builder_t;
 
 private:
   feature_builder_t const & m_Feature;
diff --git a/indexer/indexer_tool/feature_generator.cpp b/indexer/indexer_tool/feature_generator.cpp
index 2db4eb9782..e2dd878663 100644
--- a/indexer/indexer_tool/feature_generator.cpp
+++ b/indexer/indexer_tool/feature_generator.cpp
@@ -164,7 +164,7 @@ uint32_t FeaturesCollector::GetFileSize(FileWriter const & f)
   return ret;
 }
 
-void FeaturesCollector::WriteFeatureBase(vector<char> const & bytes, FeatureBuilderGeom const & fb)
+void FeaturesCollector::WriteFeatureBase(vector<char> const & bytes, FeatureBuilder1 const & fb)
 {
   size_t const sz = bytes.size();
   CHECK ( sz != 0, ("Empty feature not allowed here!") );
@@ -178,11 +178,11 @@ void FeaturesCollector::WriteFeatureBase(vector<char> const & bytes, FeatureBuil
   }
 }
 
-void FeaturesCollector::operator() (FeatureBuilderGeom const & fb)
+void FeaturesCollector::operator() (FeatureBuilder1 const & fb)
 {
   (void)GetFileSize(m_datFile);
 
-  FeatureBuilderGeom::buffers_holder_t bytes;
+  FeatureBuilder1::buffer_t bytes;
   fb.Serialize(bytes);
   WriteFeatureBase(bytes, fb);
 }
diff --git a/indexer/indexer_tool/feature_generator.hpp b/indexer/indexer_tool/feature_generator.hpp
index 80263fe7a3..b7914a9abb 100644
--- a/indexer/indexer_tool/feature_generator.hpp
+++ b/indexer/indexer_tool/feature_generator.hpp
@@ -9,8 +9,7 @@
 #include "../../std/vector.hpp"
 #include "../../std/string.hpp"
 
-class FeatureBuilderGeom;
-class FeatureBuilderGeomRef;
+class FeatureBuilder1;
 
 namespace feature
 {
@@ -44,7 +43,7 @@ namespace feature
 
     void WriteHeader();
 
-    void WriteFeatureBase(vector<char> const & bytes, FeatureBuilderGeom const & fb);
+    void WriteFeatureBase(vector<char> const & bytes, FeatureBuilder1 const & fb);
 
   public:
     // Stores prefix and suffix of a dat file name.
@@ -54,6 +53,6 @@ namespace feature
     FeaturesCollector(string const & bucket, InitDataType const & prefix);
     ~FeaturesCollector();
 
-    void operator() (FeatureBuilderGeom const & f);
+    void operator() (FeatureBuilder1 const & f);
   };
 }
diff --git a/indexer/indexer_tool/feature_sorter.cpp b/indexer/indexer_tool/feature_sorter.cpp
index 701f79c824..57e8643a0d 100644
--- a/indexer/indexer_tool/feature_sorter.cpp
+++ b/indexer/indexer_tool/feature_sorter.cpp
@@ -34,28 +34,28 @@ namespace
   public:
     std::vector<TCellAndOffset> m_vec;
 
-    void operator() (FeatureGeom const & ft, uint64_t pos)
+    void operator() (FeatureBuilder1 const & ft, uint64_t pos)
     {
       // reset state
       m_midX = 0.0;
       m_midY = 0.0;
       m_counter = 0;
-      ft.ForEachPointRef(*this, FeatureGeom::m_defScale);
+      ft.ForEachPointRef(*this);
       m_midX /= m_counter;
       m_midY /= m_counter;
 
       uint64_t const pointAsInt64 = PointToInt64(m_midX, m_midY);
-      uint64_t const minScale = feature::MinDrawableScaleForFeature(ft);
+      uint64_t const minScale = feature::MinDrawableScaleForFeature(ft.GetFeatureBase());
       CHECK(minScale <= scales::GetUpperScale(), ("Dat file contain invisible feature"));
 
       uint64_t const order = (minScale << 59) | (pointAsInt64 >> 5);
       m_vec.push_back(make_pair(order, pos));
     }
 
-    void operator() (CoordPointT const & point)
+    void operator() (m2::PointD const & p)
     {
-      m_midX += point.first;
-      m_midY += point.second;
+      m_midX += p.x;
+      m_midY += p.y;
       ++m_counter;
     }
   };
@@ -75,7 +75,7 @@ namespace feature
     if (in.size() >= 2)
     {
       SimplifyNearOptimal<mn::DistanceToLineSquare<m2::PointD> >(20, in.begin(), in.end()-1,
-        my::sq(scales::GetEpsilonForLevel(level + 1)), MakeBackInsertFunctor(out));
+        my::sq(scales::GetEpsilonForSimplify(level)), MakeBackInsertFunctor(out));
 
       switch (out.size())
       {
@@ -91,6 +91,8 @@ namespace feature
     }
   }
 
+  void TesselateInterior(points_t const & bound, list<points_t> const & holes, points_t & triangles);
+
 
   class FeaturesCollectorRef : public FeaturesCollector
   {
@@ -146,35 +148,56 @@ namespace feature
       m_writer.Finish();
     }
 
-    void operator() (FeatureBuilderGeomRef const & fb)
+    void operator() (FeatureBuilder2 & fb)
     {
       (void)GetFileSize(m_datFile);
 
-      FeatureBuilderGeomRef::buffers_holder_t buffer;
+      FeatureBuilder2::buffers_holder_t buffer;
 
       int lowS = 0;
       for (int i = 0; i < m_scales; ++i)
       {
         if (fb.IsDrawableLikeLine(lowS, g_arrScales[i]))
         {
-          buffer.m_mask |= (1 << i);
+          buffer.m_lineMask |= (1 << i);
 
           buffer.m_lineOffset.push_back(GetFileSize(*m_geoFile[i]));
 
-          // serialize points
+          // simplify and serialize geometry
           points_t points;
           SimplifyPoints(fb.GetGeometry(), points, g_arrScales[i]);
-          feature::SerializePoints(points, *m_geoFile[i]);
+          feature::SavePoints(points, *m_geoFile[i]);
+
+          if (fb.IsDrawableLikeArea() && points.size() > 2)
+          {
+            // simplify and serialize triangles
+
+            list<points_t> const & holes = fb.GetHoles();
+            list<points_t> simpleHoles;
+            for (list<points_t>::const_iterator iH = holes.begin(); iH != holes.end(); ++iH)
+            {
+              simpleHoles.push_back(points_t());
+
+              SimplifyPoints(*iH, simpleHoles.back(), g_arrScales[i]);
+
+              if (simpleHoles.back().size() < 3)
+                simpleHoles.pop_back();
+            }
+
+            points_t triangles;
+            feature::TesselateInterior(points, simpleHoles, triangles);
+
+            if (!triangles.empty())
+            {
+              buffer.m_trgMask |= (1 << i);
+              buffer.m_trgOffset.push_back(GetFileSize(*m_trgFile[i]));
+              feature::SaveTriangles(triangles, *m_trgFile[i]);
+            }
+          }
         }
         lowS = g_arrScales[i]+1;
       }
 
-      if (!fb.GetTriangles().empty())
-      {
-        buffer.m_trgOffset.push_back(GetFileSize(*m_trgFile[0]));
-        feature::SerializeTriangles(fb.GetTriangles(), *m_trgFile[0]);
-      }
-
       fb.Serialize(buffer);
 
       WriteFeatureBase(buffer.m_buffer, fb);
@@ -210,20 +233,17 @@ namespace feature
 
       FeaturesCollectorRef collector(datFilePath);
 
-      FeatureGeom::read_source_t buffer;
+      FeatureBuilder1::buffer_t buffer;
       for (size_t i = 0; i < midPoints.m_vec.size(); ++i)
       {
         ReaderSource<FileReader> src(reader);
         src.Skip(midPoints.m_vec[i].second);
 
-        FeatureGeom f;
-        feature::ReadFromSource(src, f, buffer);
-
-        FeatureBuilderType fb;
-        f.InitFeatureBuilder(fb);
+        FeatureBuilder1 f;
+        feature::ReadFromSourceRowFormat(src, f);
 
         // emit the feature
-        collector(fb);
+        collector(static_cast<FeatureBuilder2 &>(f));
       }
 
       // at this point files should be closed
diff --git a/indexer/indexer_tool/osm_element.hpp b/indexer/indexer_tool/osm_element.hpp
index 817a044798..ba5ce325eb 100644
--- a/indexer/indexer_tool/osm_element.hpp
+++ b/indexer/indexer_tool/osm_element.hpp
@@ -16,11 +16,6 @@
 
 #include "../../base/start_mem_debug.hpp"
 
-namespace feature
-{
-  typedef list<vector<m2::PointD> > holes_cont_t;
-  void TesselateInterior(FeatureBuilderGeom & featureBuilder, feature::holes_cont_t const & holes);
-}
 
 /// @param  TEmitter  Feature accumulating policy
 /// @param  THolder   Nodes, ways, relations holder
@@ -49,7 +44,7 @@ protected:
 
   public:
     /// @param[out] list of holes
-    feature::holes_cont_t m_holes;
+    list<vector<m2::PointD> > m_holes;
 
     multipolygon_processor(uint64_t id, THolder & holder) : m_id(id), m_holder(holder) {}
 
@@ -185,7 +180,7 @@ protected:
     }
   } m_typeProcessor;
 
-  typedef FeatureBuilderGeom feature_builder_t;
+  typedef FeatureBuilder1 feature_builder_t;
 
   bool GetPoint(uint64_t id, m2::PointD & pt)
   {
@@ -198,7 +193,7 @@ protected:
     {
       multipolygon_processor processor(id, m_holder);
       m_holder.ForEachRelationByWay(id, processor);
-      feature::TesselateInterior(ft, processor.m_holes);
+      ft.SetAreaAddHoles(processor.m_holes);
     }
   }
 
@@ -370,7 +365,7 @@ protected:
       if (p->childs.empty() || !base_type::GetPoint(id, pt))
         return;
 
-      ft.AddPoint(pt);
+      ft.SetCenter(pt);
     }
     else if (p->name == "way")
     {
@@ -396,12 +391,13 @@ protected:
         }
       }
 
-      if (ft.GetPointsCount() <= 1)
+      size_t const count = ft.GetPointsCount();
+      if (count < 2)
         return;
 
       // Get the tesselation for an area object (only if it has area drawing rules,
       // otherwise it will stay a linear object).
-      if (isArea)
+      if (isArea && count > 2)
         base_type::FinishAreaFeature(id, ft);
     }
     else
diff --git a/indexer/indexer_tool/tesselator.cpp b/indexer/indexer_tool/tesselator.cpp
index 659874307e..da344d0bd5 100644
--- a/indexer/indexer_tool/tesselator.cpp
+++ b/indexer/indexer_tool/tesselator.cpp
@@ -1,4 +1,4 @@
-#include "osm_element.hpp"
+#include "../../base/SRC_FIRST.hpp"
 
 #include "../cell_id.hpp"
 
@@ -11,16 +11,17 @@ namespace feature
     tess::Tesselator & m_tess;
     AddTessPointF(tess::Tesselator & tess) : m_tess(tess)
     {}
-    void operator()(CoordPointT const & p)
+    void operator()(m2::PointD const & p)
     {
-      m_tess.add(tess::Vertex(p.first, p.second));
+      m_tess.add(tess::Vertex(p.x, p.y));
     }
   };
 
-  void TesselateInterior(FeatureBuilderGeom & fb, feature::holes_cont_t const & holes)
-  {
-    ASSERT(fb.IsGeometryClosed(), ());
+  typedef vector<m2::PointD> points_t;
 
+  void TesselateInterior( points_t const & bound, list<points_t> const & holes,
+                          points_t & triangles)
+  {
     tess::VectorDispatcher disp;
     tess::Tesselator tess;
     tess.setDispatcher(&disp);
@@ -29,19 +30,13 @@ namespace feature
     tess.beginPolygon();
 
     tess.beginContour();
-    {
-      FeatureGeom::read_source_t bytes;
-      fb.Serialize(bytes.m_data);
-      FeatureGeom f(bytes);
-      f.ForEachPoint(AddTessPointF(tess), FeatureGeom::m_defScale);
-    }
+    for_each(bound.begin(), bound.end(), AddTessPointF(tess));
     tess.endContour();
 
-    for (feature::holes_cont_t::const_iterator it = holes.begin(); it != holes.end(); ++it)
+    for (list<points_t>::const_iterator it = holes.begin(); it != holes.end(); ++it)
     {
       tess.beginContour();
-      for (size_t i = 0; i < (*it).size(); ++i)
-        tess.add(tess::Vertex((*it)[i].x, (*it)[i].y));
+      for_each(it->begin(), it->end(), AddTessPointF(tess));
       tess.endContour();
     }
 
@@ -49,7 +44,6 @@ namespace feature
 
     for (size_t i = 0; i < disp.indices().size(); ++i)
     {
-      vector<m2::PointD> vertices;
       switch (disp.indices()[i].first)
       {
       case tess::TrianglesFan:
@@ -63,13 +57,10 @@ namespace feature
       {
         int const idx = disp.indices()[i].second[j];
         tess::Vertex const & v = disp.vertices()[idx];
-        vertices.push_back(m2::PointD(v.x, v.y));
+        triangles.push_back(m2::PointD(v.x, v.y));
       }
 
-      ASSERT_EQUAL(vertices.size() % 3, 0, ());
-      size_t const triangleCount = vertices.size() / 3;
-      for (size_t i = 0; i < triangleCount; ++i)
-        fb.AddTriangle(vertices[3*i + 0], vertices[3*i + 1], vertices[3*i + 2]);
+      ASSERT_EQUAL(triangles.size() % 3, 0, ());
     }
   }
 }
diff --git a/indexer/scale_index_builder.hpp b/indexer/scale_index_builder.hpp
index 8d755fc077..dbaefc4840 100644
--- a/indexer/scale_index_builder.hpp
+++ b/indexer/scale_index_builder.hpp
@@ -75,7 +75,8 @@ public:
   template <class TFeature>
   bool FeatureShouldBeIndexed(TFeature const & f) const
   {
-    (void)f.GetLimitRect(); // dummy call to force TFeature::ParseGeometry
+    // Call this to force TFeature::ParseGeometry
+    f.GetLimitRect(m_ScaleRange.second);
 
     uint32_t const minScale = feature::MinDrawableScaleForFeature(f);
     return (m_ScaleRange.first <= minScale && minScale < m_ScaleRange.second);
diff --git a/indexer/scales.cpp b/indexer/scales.cpp
index eb56ff1a99..978698663e 100644
--- a/indexer/scales.cpp
+++ b/indexer/scales.cpp
@@ -41,9 +41,22 @@ namespace scales
     return GetScaleLevel((dx + dy) / 2.0);
   }
 
+  namespace
+  {
+    double GetEpsilonImpl(int level, int logEps)
+    {
+      return (MercatorBounds::maxX - MercatorBounds::minX) / pow(2.0, double(level + logEps - initial_level));
+    }
+  }
+
   double GetEpsilonForLevel(int level)
   {
-    return (MercatorBounds::maxX - MercatorBounds::minX) / pow(2.0, double(level + 6 - initial_level));
+    return GetEpsilonImpl(level, 6);
+  }
+
+  double GetEpsilonForSimplify(int level)
+  {
+    return GetEpsilonImpl(level, 9);
   }
 
   bool IsGoodForLevel(int level, m2::RectD const & r)
diff --git a/indexer/scales.hpp b/indexer/scales.hpp
index acf475e02c..0d862ef10c 100644
--- a/indexer/scales.hpp
+++ b/indexer/scales.hpp
@@ -10,5 +10,6 @@ namespace scales
   int GetScaleLevel(double ratio);
   int GetScaleLevel(m2::RectD const & r);
   double GetEpsilonForLevel(int level);
+  double GetEpsilonForSimplify(int level);
   bool IsGoodForLevel(int level, m2::RectD const & r);
 }
diff --git a/map/feature_vec_model.hpp b/map/feature_vec_model.hpp
index f82e76a6aa..3cdd2f601a 100644
--- a/map/feature_vec_model.hpp
+++ b/map/feature_vec_model.hpp
@@ -15,21 +15,6 @@
 
 namespace model
 {
-  class FeatureVector
-  {
-    vector<FeatureBuilderType> m_vec;
-    m2::RectD m_rect;
-
-  public:
-    template <class TParam, class ToDo>
-    void ForEachFeature(TParam const &, ToDo & toDo)
-    {
-      std::for_each(m_vec.begin(), m_vec.end(), toDo);
-    }
-
-    m2::RectD GetWorldRect() const { return m_rect; }
-  };
-
 //#define USE_BUFFER_READER
 
   class FeaturesFetcher
diff --git a/map/map_tests/map_foreach_test.cpp b/map/map_tests/map_foreach_test.cpp
index 454e82a287..6dfa8cf43e 100644
--- a/map/map_tests/map_foreach_test.cpp
+++ b/map/map_tests/map_foreach_test.cpp
@@ -211,8 +211,9 @@ namespace
 
     void operator() (FeatureType const & f, uint64_t offset)
     {
-      if (f.DebugString(m_level) == m_test.second)
-        LOG(LINFO, ("Offset = ", offset));
+      string const s = f.DebugString(m_level);
+      if (s == m_test.second)
+        LOG(LINFO, (s, "Feature offset = ", offset));
     }
   };
 }
@@ -247,9 +248,8 @@ UNIT_TEST(IndexForEachTest)
     size_t errInd;
     if (!compare_sequence(v2, v1, compare_strings(), errInd))
     {
-      LOG(LINFO, ("Failed for rect: ", r, ". Etalon size = ", v2.size(), ". Index size = ", v1.size()));
       src2.ForEachFeature(r, FindOffset(level, v2[errInd]));
-      TEST(false, ("Error in ForEachFeature test"));
+      TEST(false, ("Failed for rect: ", r, ". Etalon size = ", v2.size(), ". Index size = ", v1.size()));
     }
 
     if (!v2.empty() && (level < scales::GetUpperScale()))
diff --git a/qt/draw_widget.hpp b/qt/draw_widget.hpp
index 23fa3b3b15..02dc1fe489 100644
--- a/qt/draw_widget.hpp
+++ b/qt/draw_widget.hpp
@@ -30,7 +30,6 @@ namespace qt
     shared_ptr<handle_t> m_handle;
 
     typedef model::FeaturesFetcher model_t;
-    //typedef model::FeatureVector model_t;
 
     FrameWork<model_t, Navigator, handle_t> m_framework;
 
diff --git a/qt/searchwindow.hpp b/qt/searchwindow.hpp
index 794d9c973d..3d51df34e0 100644
--- a/qt/searchwindow.hpp
+++ b/qt/searchwindow.hpp
@@ -25,7 +25,6 @@ namespace qt
 
     Q_OBJECT
 
-    //typedef model::FeatureVector model_t;
     typedef model::FeaturesFetcher model_t;
 
     FindEditorWnd * m_pEditor;