diff --git a/indexer/feature.cpp b/indexer/feature.cpp
index aca73c19c7..4c4c9803fc 100644
--- a/indexer/feature.cpp
+++ b/indexer/feature.cpp
@@ -1,16 +1,13 @@
+#include "../base/SRC_FIRST.hpp"
+
 #include "feature.hpp"
-#include "cell_id.hpp"
+#include "feature_impl.hpp"
 #include "feature_visibility.hpp"
 #include "scales.hpp"
 
 #include "../geometry/rect2d.hpp"
-#include "../geometry/distance.hpp"
-#include "../geometry/simplification.hpp"
 
 #include "../coding/byte_stream.hpp"
-#include "../coding/reader.hpp"
-#include "../coding/varint.hpp"
-#include "../coding/write_to_sink.hpp"
 
 #include "../base/logging.hpp"
 
@@ -27,7 +24,7 @@ namespace pts
 
   struct Fpt2id
   {
-    int64_t operator() (m2::PointD const & p)
+    int64_t operator() (m2::PointD const & p) const
     {
       return PointToInt64(p.x, p.y);
     }
@@ -178,7 +175,7 @@ void FeatureBuilderGeom::Serialize(buffers_holder_t & data) const
   data.clear();
 
   SerializeBase(data);
-  SerializePoints(m_Geometry, data);
+  SerializePoints(data);
   SerializeTriangles(data);
 
   ASSERT ( CheckCorrect(data), () );
@@ -186,38 +183,14 @@ void FeatureBuilderGeom::Serialize(buffers_holder_t & data) const
 
 void FeatureBuilderGeom::SerializeTriangles(buffer_t & data) const
 {
-  if (!m_Triangles.empty())
-  {
-    PushBackByteSink<buffer_t> sink(data);
-
-    ASSERT_EQUAL(m_Triangles.size() % 3, 0, (m_Triangles.size()));
-    WriteVarUint(sink, m_Triangles.size() / 3 - 1);
-    for (size_t i = 0; i < m_Triangles.size(); ++i)
-      WriteVarInt(sink, i == 0 ? m_Triangles[i] : (m_Triangles[i] - m_Triangles[i-1]));
-  }
+  PushBackByteSink<buffer_t> sink(data);
+  feature::SerializeTriangles(m_Triangles, sink);
 }
 
-void FeatureBuilderGeom::SerializePoints(points_t const & points, buffer_t & data)
+void FeatureBuilderGeom::SerializePoints(buffer_t & data) const
 {
-  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), pts::Fpt2id());
-
   PushBackByteSink<buffer_t> sink(data);
-
-  if (ptsCount == 1)
-  {
-    WriteVarInt(sink, geom[0]);
-  }
-  else
-  {
-    WriteVarUint(sink, ptsCount - 1);
-    for (size_t i = 0; i < ptsCount; ++i)
-      WriteVarInt(sink, i == 0 ? geom[0] : geom[i] - geom[i-1]);
-  }
+  feature::SerializePoints(m_Geometry, sink);
 }
 
 bool FeatureBuilderGeom::CheckCorrect(vector<char> const & data) const
@@ -243,86 +216,45 @@ bool FeatureBuilderGeom::CheckCorrect(vector<char> const & data) const
 // FeatureBuilderGeomRef implementation
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool FeatureBuilderGeomRef::IsDrawable(int lowS, int highS) const
+bool FeatureBuilderGeomRef::IsDrawableLikeLine(int lowS, int highS) const
 {
-  FeatureBase const fb = GetFeatureBase();
+  if (m_Geometry.size() > 1)
+  {
+    FeatureBase const fb = GetFeatureBase();
 
-  while (lowS <= highS)
-    if (feature::IsDrawableForIndex(fb, lowS++))
-      return true;
+    while (lowS <= highS)
+      if (feature::IsDrawableForIndex(fb, lowS++))
+        return true;
+  }
 
   return false;
 }
 
-void FeatureBuilderGeomRef::SimplifyPoints(points_t const & in, points_t & out, int level) const
-{
-  if (in.size() >= 2)
-  {
-    SimplifyNearOptimal<mn::DistanceToLineSquare<m2::PointD> >(50, in.begin(), in.end()-1,
-      my::sq(scales::GetEpsilonForLevel(level + 1)), MakeBackInsertFunctor(out));
-
-    switch (out.size())
-    {
-    case 0:
-      out.push_back(in.front());
-    case 1:
-      out.push_back(in.back());
-      break;
-    default:
-      if (!out.back().EqualDxDy(in.back(), MercatorBounds::GetCellID2PointAbsEpsilon()))
-        out.push_back(in.back());
-    }
-  }
-}
-
-int g_arrScales[] = { 5, 10, 14, 17 };  // 17 = scales::GetUpperScale()
-//int g_arrScales[] = { 17 };
-
 void FeatureBuilderGeomRef::Serialize(buffers_holder_t & data) const
 {
-  data.clear();
+  data.m_buffer.clear();
 
-  SerializeBase(data.m_buffers[0]);
+  SerializeBase(data.m_buffer);
 
-  PushBackByteSink<buffer_t> sink(data.m_buffers[0]);
+  PushBackByteSink<buffer_t> sink(data.m_buffer);
 
   // for point feature write geometry-point immediately
   if (m_Geometry.size() == 1)
   {
-    SerializePoints(m_Geometry, data.m_buffers[0]);
+    SerializePoints(data.m_buffer);
   }
   else
   {
-    uint32_t mask = 0;
-    int lowS = 0;
-    vector<uint32_t> offsets;
-    for (int i = 0; i < ARRAY_SIZE(g_arrScales); ++i)
-    {
-      if (IsDrawable(lowS, g_arrScales[i]))
-      {
-        mask |= (1 << i);
-        offsets.push_back(data.m_buffers[1].size());
-
-        // serialize points
-        points_t points;
-        SimplifyPoints(m_Geometry, points, g_arrScales[i]);
-        SerializePoints(points, data.m_buffers[1]);
-      }
-      lowS = g_arrScales[i]+1;
-    }
-
-    CHECK(mask > 0, (mask));  // feature should be visible
+    CHECK(data.m_mask > 0, (data.m_mask));  // feature should be visible
 
     // serialize geometry offsets
-    WriteVarUint(sink, mask);
-    for (size_t i = 0; i < offsets.size(); ++i)
-      WriteVarUint(sink, data.m_lineOffset + offsets[i]);
-  }
+    WriteVarUint(sink, data.m_mask);
 
-  if (!m_Triangles.empty())
-  {
-    WriteVarUint(sink, data.m_trgOffset);
-    SerializeTriangles(data.m_buffers[2]);
+    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]);
   }
 }
 
@@ -534,14 +466,13 @@ void FeatureGeom::InitFeatureBuilder(FeatureBuilderGeom & fb) const
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 FeatureGeomRef::FeatureGeomRef(read_source_t & src)
- : base_type(src), m_gF(&src.m_gF), m_trgF(&src.m_trgF)
+ : base_type(src), m_cont(&src.m_cont)
 {
 }
 
 void FeatureGeomRef::Deserialize(read_source_t & src)
 {
-  m_gF = &src.m_gF;
-  m_trgF = &src.m_trgF;
+  m_cont = &src.m_cont;
 
   m_bOffsetsParsed = false;
   m_mask = 0;
@@ -552,8 +483,8 @@ void FeatureGeomRef::Deserialize(read_source_t & src)
 
 uint32_t FeatureGeomRef::GetOffset(int scale) const
 {
-  for (size_t i = 0; i < ARRAY_SIZE(g_arrScales); ++i)
-    if (scale <= g_arrScales[i])
+  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;
@@ -570,6 +501,26 @@ string FeatureGeomRef::DebugString(int scale) const
     return base_type::DebugString(scale);
 }
 
+namespace 
+{
+  inline string get_tag(char const * prefix, int scale)
+  {
+    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;
+  }
+}
+
 void FeatureGeomRef::ParseGeometry(int scale) const
 {
   if (!m_bOffsetsParsed)
@@ -578,7 +529,7 @@ void FeatureGeomRef::ParseGeometry(int scale) const
   if (m_bGeometryParsed)
     return;
 
-  ReaderSource<FileReader> source(*m_gF);
+  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);
@@ -591,7 +542,7 @@ void FeatureGeomRef::ParseTriangles(int scale) const
   if (!m_bOffsetsParsed)
     ParseOffsets();
 
-  ReaderSource<FileReader> source(*m_trgF);
+  ReaderSource<FileReader> source(m_cont->GetReader(get_tag(TRIANGLE_FILE_TAG, 0)));
   source.Skip(m_trgOffset);
 
   ParseTrianglesImpl(source);
diff --git a/indexer/feature.hpp b/indexer/feature.hpp
index 4d82e736d0..75c3d2facf 100644
--- a/indexer/feature.hpp
+++ b/indexer/feature.hpp
@@ -7,7 +7,7 @@
 #include "../geometry/point2d.hpp"
 #include "../geometry/rect2d.hpp"
 
-#include "../coding/file_reader.hpp"
+#include "../coding/file_container.hpp"
 
 #include "../base/base.hpp"
 
@@ -60,7 +60,7 @@ protected:
   typedef vector<m2::PointD> points_t;
 
   void SerializeBase(buffer_t & data) const;
-  static void SerializePoints(points_t const & points, buffer_t & data);
+  void SerializePoints(buffer_t & data) const;
   void SerializeTriangles(buffer_t & data) const;
 
   uint8_t GetHeader() const;
@@ -82,23 +82,24 @@ class FeatureBuilderGeomRef : public FeatureBuilderGeom
 {
   typedef FeatureBuilderGeom base_type;
 
-  bool IsDrawable(int lowS, int highS) const;
-  void SimplifyPoints(points_t const & in, points_t & out, int level) const;
-
 public:
 
   struct buffers_holder_t
   {
-    uint32_t m_lineOffset, m_trgOffset; ///< in
-    base_type::buffer_t m_buffers[3];   ///< out
+    vector<uint32_t> m_lineOffset;  // in
+    vector<uint32_t> m_trgOffset;   // in
+    uint32_t m_mask;
 
-    void clear()
-    {
-      for (int i = 0; i < 3; ++i)
-        m_buffers[i].clear();
-    }
+    base_type::buffer_t m_buffer;   // out
+
+    buffers_holder_t() : m_mask(0) {}
   };
 
+  bool IsDrawableLikeLine(int lowS, int highS) const;
+
+  points_t const & GetGeometry() const { return m_Geometry; }
+  vector<int64_t> const & GetTriangles() const { return m_Triangles; }
+
   /// @name Overwrite from base_type.
   //@{
   void Serialize(buffers_holder_t & data) const;
@@ -338,13 +339,8 @@ class FeatureGeomRef : public FeatureGeom
 public:
   struct read_source_t : public base_type::read_source_t
   {
-    FileReader m_gF;
-    FileReader m_trgF;
-
-    read_source_t(FileReader const & gF, FileReader const & trgF)
-      : m_gF(gF), m_trgF(trgF)
-    {
-    }
+    FilesContainerR m_cont;
+    read_source_t(FilesContainerR const & cont) : m_cont(cont) {}
   };
 
   FeatureGeomRef() {}
@@ -361,8 +357,7 @@ protected:
   //@}
 
 private:
-  FileReader * m_gF;
-  FileReader * m_trgF;
+  FilesContainerR * m_cont;
 
   void ParseOffsets() const;
   mutable bool m_bOffsetsParsed;
diff --git a/indexer/feature_impl.hpp b/indexer/feature_impl.hpp
new file mode 100644
index 0000000000..8f7a914ec1
--- /dev/null
+++ b/indexer/feature_impl.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include "cell_id.hpp"
+
+#include "../coding/write_to_sink.hpp"
+#include "../coding/varint.hpp"
+
+#include "../geometry/point2d.hpp"
+
+namespace feature
+{
+  namespace detail
+  {
+    struct pt_2_id
+    {
+      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]);
+    }
+    else
+    {
+      WriteVarUint(sink, ptsCount - 1);
+      for (size_t i = 0; i < ptsCount; ++i)
+        WriteVarInt(sink, i == 0 ? geom[0] : geom[i] - geom[i-1]);
+    }
+  }
+
+  template <class TSink>
+  void SerializeTriangles(vector<int64_t> triangles, 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]));
+    }
+  }
+
+  static int g_arrScales[] = { 5, 10, 14, 17 };  // 17 = scales::GetUpperScale()
+}
diff --git a/indexer/feature_processor.hpp b/indexer/feature_processor.hpp
index 1991a5a673..e9e09fe00d 100644
--- a/indexer/feature_processor.hpp
+++ b/indexer/feature_processor.hpp
@@ -13,7 +13,7 @@ namespace feature
   void ForEachFromDat(string const & fName, ToDo & toDo)
   {
     FilesContainerR container(fName);
-    FeaturesVector<FileReader> featureSource(container);
+    FeaturesVector featureSource(container);
     featureSource.ForEachOffset(bind<void>(ref(toDo), _1, _2));
   }
 
diff --git a/indexer/features_vector.hpp b/indexer/features_vector.hpp
index d1612b5fa6..a4bfe3ba1e 100644
--- a/indexer/features_vector.hpp
+++ b/indexer/features_vector.hpp
@@ -11,30 +11,24 @@
 //#include "../std/bind.hpp"
 
 
-template <class ReaderT>
 struct FeatureReaders
 {
-  ReaderT m_datR, m_geomR, m_trgR;
+  FilesContainerR m_cont;
+  FileReader m_datR;
 
-  template <class ContainerT>
-  FeatureReaders(ContainerT const & cont)
-    : m_datR(cont.GetReader(DATA_FILE_TAG)),
-      m_geomR(cont.GetReader(GEOMETRY_FILE_TAG)),
-      m_trgR(cont.GetReader(TRIANGLE_FILE_TAG))
+  FeatureReaders(FilesContainerR const & cont)
+    : m_cont(cont), m_datR(cont.GetReader(DATA_FILE_TAG))
   {
     uint64_t const offset = feature::GetSkipHeaderSize(m_datR);
     m_datR = m_datR.SubReader(offset, m_datR.Size() - offset);
   }
 };
 
-template <typename ReaderT>
 class FeaturesVector
 {
 public:
-  typedef ReaderT ReaderType;
-
-  FeaturesVector(FeatureReaders<ReaderT> const & dataR)
-    : m_RecordReader(dataR.m_datR, 256), m_source(dataR.m_geomR, dataR.m_trgR)
+  FeaturesVector(FeatureReaders const & dataR)
+    : m_RecordReader(dataR.m_datR, 256), m_source(dataR.m_cont)
   {
   }
 
@@ -81,6 +75,6 @@ private:
     }
   };
 
-  VarRecordReader<ReaderT, &VarRecordSizeReaderVarint> m_RecordReader;
+  VarRecordReader<FileReader, &VarRecordSizeReaderVarint> m_RecordReader;
   mutable FeatureType::read_source_t m_source;
 };
diff --git a/indexer/index.hpp b/indexer/index.hpp
index b0553b80d0..8349b6dc8e 100644
--- a/indexer/index.hpp
+++ b/indexer/index.hpp
@@ -91,7 +91,7 @@ public:
 
   void Add(string const & path)
   {
-    uint32_t const logPageSize = 12;
+    uint32_t const logPageSize = 10;
     uint32_t const logPageCount = 12;
     FilesContainerR container(path, logPageSize, logPageCount);
     m_Indexes.push_back(new IndexT(container));
@@ -134,7 +134,7 @@ public:
 
   explicit OffsetToFeatureAdapter(FilesContainerR const & container)
   : BaseT(container.GetReader(INDEX_FILE_TAG)),
-    m_FeatureVector(FeatureReaders<FileReader>(container))
+    m_FeatureVector(container)
   {
   }
 
@@ -221,7 +221,7 @@ struct Index
 {
   typedef IndexForEachAdapter<
             MultiIndexAdapter<
-              OffsetToFeatureAdapter<FeaturesVector<ReaderT>,
+              OffsetToFeatureAdapter<FeaturesVector,
                 UniqueOffsetAdapter<
                   ScaleIndex<ReaderT>
                 >
diff --git a/indexer/index_builder.cpp b/indexer/index_builder.cpp
index 35579c1418..a2cd96b5d9 100644
--- a/indexer/index_builder.cpp
+++ b/indexer/index_builder.cpp
@@ -14,7 +14,7 @@ namespace indexer
     try
     {
       FilesContainerR readCont(datFile);
-      FeaturesVector<FileReader> featuresVector(readCont);
+      FeaturesVector featuresVector(readCont);
 
       FilesContainerW writeCont(datFile, FileWriter::OP_APPEND);
       FileWriter writer = writeCont.GetWriter(INDEX_FILE_TAG);
diff --git a/indexer/indexer.pro b/indexer/indexer.pro
index a8c4b82ed7..8bab7dfdcf 100644
--- a/indexer/indexer.pro
+++ b/indexer/indexer.pro
@@ -67,3 +67,4 @@ HEADERS += \
   data_header.hpp \
   data_header_reader.hpp \
   tree_structure.hpp \
+  feature_impl.hpp \
diff --git a/indexer/indexer_tests/feature_routine.cpp b/indexer/indexer_tests/feature_routine.cpp
index d9fb82b696..41d258adaa 100644
--- a/indexer/indexer_tests/feature_routine.cpp
+++ b/indexer/indexer_tests/feature_routine.cpp
@@ -2,37 +2,36 @@
 
 #include "feature_routine.hpp"
 
+#include "../feature_impl.hpp"
+
 #include "../../coding/file_writer.hpp"
 
 
-void WriteToFile(string const & fName, vector<char> const & buffer)
-{
-  FileWriter writer(fName);
-  if (!buffer.empty())
-    writer.Write(&buffer[0], buffer.size());
-}
-
 namespace
 {
   class feature_source_initializer
   {
     string m_name;
-  public:
     FeatureGeomRef::read_source_t * m_source;
 
+  public:
     feature_source_initializer(string const & fName)
-      : m_name(fName)
+      : m_name(fName), m_source(0)
     {
-      m_source = new FeatureGeomRef::read_source_t(
-        FileReader(fName + ".geom"), FileReader(fName + ".trg"));
+    }
+
+    FeatureGeomRef::read_source_t & get_source(vector<char> & buffer)
+    {
+      delete m_source;
+      m_source = new FeatureGeomRef::read_source_t(FilesContainerR(m_name));
+      m_source->m_data.swap(buffer);
+      return *m_source;
     }
 
     ~feature_source_initializer()
     {
       delete m_source;
-
-      FileWriter::DeleteFile(m_name + ".geom");
-      FileWriter::DeleteFile(m_name + ".trg");
+      FileWriter::DeleteFile(m_name);
     }
   };
 }
@@ -42,15 +41,29 @@ void FeatureBuilder2Feature(FeatureBuilderGeomRef const & fb, FeatureGeomRef & f
   string const datFile = "indexer_tests_tmp.dat";
 
   FeatureBuilderGeomRef::buffers_holder_t buffers;
-  buffers.m_lineOffset = buffers.m_trgOffset = 0;
+  buffers.m_lineOffset.push_back(0);
+  buffers.m_trgOffset.push_back(0);
+  buffers.m_mask = 1;
   fb.Serialize(buffers);
 
-  WriteToFile(datFile + ".geom", buffers.m_buffers[1]);
-  WriteToFile(datFile + ".trg", buffers.m_buffers[2]);
+  {
+    FilesContainerW writer(datFile);
+
+    {
+      FileWriter geom = writer.GetWriter(string(GEOMETRY_FILE_TAG) + '0');
+      feature::SerializePoints(fb.GetGeometry(), geom);
+    }
+
+    {
+      FileWriter trg = writer.GetWriter(string(TRIANGLE_FILE_TAG) + '0');
+      feature::SerializeTriangles(fb.GetTriangles(), trg);
+    }
+
+    writer.Finish();
+  }
 
   static feature_source_initializer staticInstance(datFile);
-  staticInstance.m_source->m_data.swap(buffers.m_buffers[0]);
-  f.Deserialize(*staticInstance.m_source);
+  f.Deserialize(staticInstance.get_source(buffers.m_buffer));
 }
 
 void Feature2FeatureBuilder(FeatureGeomRef const & f, FeatureBuilderGeomRef & fb)
diff --git a/indexer/indexer_tests/feature_test.cpp b/indexer/indexer_tests/feature_test.cpp
index 51c0fb9188..0718008dd3 100644
--- a/indexer/indexer_tests/feature_test.cpp
+++ b/indexer/indexer_tests/feature_test.cpp
@@ -102,7 +102,7 @@ UNIT_TEST(Feature_Deserialize)
   //TEST_EQUAL(f.GetGeometrySize(), 4, ());
   //TEST_EQUAL(f.GetTriangleCount(), 1, ());
 
-  int const level = FeatureType::m_defScale;
+  int const level = 0;
 
   PointAccumulator featurePoints;
   f.ForEachPointRef(featurePoints, level);
diff --git a/indexer/indexer_tests/index_builder_test.cpp b/indexer/indexer_tests/index_builder_test.cpp
index 7eeae0abe7..f6616b116c 100644
--- a/indexer/indexer_tests/index_builder_test.cpp
+++ b/indexer/indexer_tests/index_builder_test.cpp
@@ -23,7 +23,7 @@ UNIT_TEST(BuildIndexTest)
   // Build index.
   vector<char> serialIndex;
   {
-    FeaturesVector<FileReader> featuresVector(originalContainer);
+    FeaturesVector featuresVector(originalContainer);
     MemWriter<vector<char> > serialWriter(serialIndex);
     indexer::BuildIndex(featuresVector, serialWriter, "build_index_test");
   }
@@ -42,9 +42,13 @@ UNIT_TEST(BuildIndexTest)
       if (tags[i] != INDEX_FILE_TAG)
       {
         FileReader reader = originalContainer.GetReader(tags[i]);
-        vector<char> data(reader.Size());
-        reader.Read(0, &data[0], data.size());
-        containerWriter.Append(data, tags[i]);
+        uint64_t const sz = reader.Size();
+        if (sz > 0)
+        {
+          vector<char> data(sz);
+          reader.Read(0, &data[0], sz);
+          containerWriter.Append(data, tags[i]);
+        }
       }
     }
     containerWriter.Append(serialIndex, INDEX_FILE_TAG);
diff --git a/indexer/indexer_tool/feature_generator.cpp b/indexer/indexer_tool/feature_generator.cpp
index 5e39fcd5b9..2db4eb9782 100644
--- a/indexer/indexer_tool/feature_generator.cpp
+++ b/indexer/indexer_tool/feature_generator.cpp
@@ -154,18 +154,14 @@ FeaturesCollector::FeaturesCollector(string const & bucket,
   Init();
 }
 
-void FeaturesCollector::FilePreCondition(FileWriter const & f)
+uint32_t FeaturesCollector::GetFileSize(FileWriter const & f)
 {
   // .dat file should be less than 4Gb
   uint64_t const pos = f.Pos();
-  CHECK_EQUAL ( static_cast<uint64_t>(static_cast<uint32_t>(pos)), pos,
-    ("Feature offset is out of 32bit boundary!") );
-}
+  uint32_t const ret = static_cast<uint32_t>(pos);
 
-void FeaturesCollector::WriteBuffer(FileWriter & f, vector<char> const & bytes)
-{
-  if (!bytes.empty())
-    f.Write(&bytes[0], bytes.size());
+  CHECK_EQUAL(static_cast<uint64_t>(ret), pos, ("Feature offset is out of 32bit boundary!"));
+  return ret;
 }
 
 void FeaturesCollector::WriteFeatureBase(vector<char> const & bytes, FeatureBuilderGeom const & fb)
@@ -184,7 +180,7 @@ void FeaturesCollector::WriteFeatureBase(vector<char> const & bytes, FeatureBuil
 
 void FeaturesCollector::operator() (FeatureBuilderGeom const & fb)
 {
-  FilePreCondition(m_datFile);
+  (void)GetFileSize(m_datFile);
 
   FeatureBuilderGeom::buffers_holder_t bytes;
   fb.Serialize(bytes);
@@ -205,51 +201,6 @@ FeaturesCollector::~FeaturesCollector()
   WriteHeader();
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////
-// FeaturesCollectorRef implementation
-/////////////////////////////////////////////////////////////////////////////////////////
-
-FeaturesCollectorRef::FeaturesCollectorRef(string const & fName)
-: FeaturesCollector(fName + DATA_FILE_TAG),
-  m_writer(fName),
-  m_geoFile(fName + GEOMETRY_FILE_TAG),
-  m_trgFile(fName + TRIANGLE_FILE_TAG)
-{
-}
-
-void FeaturesCollectorRef::operator() (FeatureBuilderGeomRef const & fb)
-{
-  FilePreCondition(m_datFile);
-  FilePreCondition(m_geoFile);
-  FilePreCondition(m_trgFile);
-
-  FeatureBuilderGeomRef::buffers_holder_t buffers;
-  buffers.m_lineOffset = static_cast<uint32_t>(m_geoFile.Pos());
-  buffers.m_trgOffset = static_cast<uint32_t>(m_trgFile.Pos());
-
-  fb.Serialize(buffers);
-  WriteFeatureBase(buffers.m_buffers[0], fb);
-
-  WriteBuffer(m_geoFile, buffers.m_buffers[1]);
-  WriteBuffer(m_trgFile, buffers.m_buffers[2]);
-}
-
-FeaturesCollectorRef::~FeaturesCollectorRef()
-{
-  WriteHeader();
-
-  // assume like we close files
-  m_datFile.Flush();
-  m_geoFile.Flush();
-  m_trgFile.Flush();
-
-  // make one file container
-  m_writer.Append(m_datFile.GetName(), DATA_FILE_TAG);
-  m_writer.Append(m_geoFile.GetName(), GEOMETRY_FILE_TAG);
-  m_writer.Append(m_trgFile.GetName(), TRIANGLE_FILE_TAG);
-  m_writer.Finish();
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Generate functions implementations.
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/indexer/indexer_tool/feature_generator.hpp b/indexer/indexer_tool/feature_generator.hpp
index a5d770bd8b..80263fe7a3 100644
--- a/indexer/indexer_tool/feature_generator.hpp
+++ b/indexer/indexer_tool/feature_generator.hpp
@@ -39,11 +39,11 @@ namespace feature
 
   protected:
     void Init();
-    void FilePreCondition(FileWriter const & f);
+
+    uint32_t GetFileSize(FileWriter const & f);
 
     void WriteHeader();
 
-    static void WriteBuffer(FileWriter & f, vector<char> const & bytes);
     void WriteFeatureBase(vector<char> const & bytes, FeatureBuilderGeom const & fb);
 
   public:
@@ -56,16 +56,4 @@ namespace feature
 
     void operator() (FeatureBuilderGeom const & f);
   };
-
-  class FeaturesCollectorRef : public FeaturesCollector
-  {
-    FilesContainerW m_writer;
-    FileWriter m_geoFile, m_trgFile;
-
-  public:
-    explicit FeaturesCollectorRef(string const & fName);
-    ~FeaturesCollectorRef();
-
-    void operator() (FeatureBuilderGeomRef const & f);
-  };
 }
diff --git a/indexer/indexer_tool/feature_sorter.cpp b/indexer/indexer_tool/feature_sorter.cpp
index 20b094bff6..701f79c824 100644
--- a/indexer/indexer_tool/feature_sorter.cpp
+++ b/indexer/indexer_tool/feature_sorter.cpp
@@ -4,14 +4,20 @@
 #include "../../indexer/data_header.hpp"
 #include "../../indexer/feature_processor.hpp"
 #include "../../indexer/feature_visibility.hpp"
+#include "../../indexer/feature_impl.hpp"
 #include "../../indexer/scales.hpp"
 #include "../../indexer/cell_id.hpp"
 
+#include "../../geometry/distance.hpp"
+#include "../../geometry/simplification.hpp"
+
 #include "../../platform/platform.hpp"
 
-#include "../../coding/file_writer.hpp"
+#include "../../coding/file_container.hpp"
 
+#include "../../base/string_utils.hpp"
 #include "../../base/logging.hpp"
+
 #include "../../base/start_mem_debug.hpp"
 
 
@@ -62,7 +68,121 @@ namespace
 
 namespace feature
 {
-  bool SortDatFile(string const & datFilePath, bool removeOriginalFile)
+  typedef vector<m2::PointD> points_t;
+
+  void SimplifyPoints(points_t const & in, points_t & out, int level)
+  {
+    if (in.size() >= 2)
+    {
+      SimplifyNearOptimal<mn::DistanceToLineSquare<m2::PointD> >(20, in.begin(), in.end()-1,
+        my::sq(scales::GetEpsilonForLevel(level + 1)), MakeBackInsertFunctor(out));
+
+      switch (out.size())
+      {
+      case 0:
+        out.push_back(in.front());
+      case 1:
+        out.push_back(in.back());
+        break;
+      default:
+        if (!out.back().EqualDxDy(in.back(), MercatorBounds::GetCellID2PointAbsEpsilon()))
+          out.push_back(in.back());
+      }
+    }
+  }
+
+
+  class FeaturesCollectorRef : public FeaturesCollector
+  {
+    FilesContainerW m_writer;
+
+    vector<FileWriter*> m_geoFile, m_trgFile;
+
+    static const int m_scales = ARRAY_SIZE(g_arrScales);
+
+  public:
+    explicit FeaturesCollectorRef(string const & fName)
+      : FeaturesCollector(fName + DATA_FILE_TAG), m_writer(fName)
+    {
+      for (int i = 0; i < m_scales; ++i)
+      {
+        string const postfix = utils::to_string(i);
+        m_geoFile.push_back(new FileWriter(fName + GEOMETRY_FILE_TAG + postfix));
+        m_trgFile.push_back(new FileWriter(fName + TRIANGLE_FILE_TAG + postfix));
+      }
+    }
+
+    ~FeaturesCollectorRef()
+    {
+      WriteHeader();
+
+      // assume like we close files
+      m_datFile.Flush();
+
+      m_writer.Append(m_datFile.GetName(), DATA_FILE_TAG);
+
+      for (int i = 0; i < m_scales; ++i)
+      {
+        string const geomFile = m_geoFile[i]->GetName();
+        string const trgFile = m_trgFile[i]->GetName();
+
+        delete m_geoFile[i];
+        delete m_trgFile[i];
+
+        string const postfix = utils::to_string(i);
+
+        string geoPostfix = GEOMETRY_FILE_TAG;
+        geoPostfix += postfix;
+        string trgPostfix = TRIANGLE_FILE_TAG;
+        trgPostfix += postfix;
+
+        m_writer.Append(geomFile, geoPostfix);
+        m_writer.Append(trgFile, trgPostfix);
+
+        FileWriter::DeleteFile(geomFile);
+        FileWriter::DeleteFile(trgFile);
+      }
+
+      m_writer.Finish();
+    }
+
+    void operator() (FeatureBuilderGeomRef const & fb)
+    {
+      (void)GetFileSize(m_datFile);
+
+      FeatureBuilderGeomRef::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_lineOffset.push_back(GetFileSize(*m_geoFile[i]));
+
+          // serialize points
+          points_t points;
+          SimplifyPoints(fb.GetGeometry(), points, g_arrScales[i]);
+          feature::SerializePoints(points, *m_geoFile[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);
+    }
+  };
+
+
+  bool GenerateFinalFeatures(string const & datFilePath, bool bSort)
   {
     // rename input file
     Platform & platform = GetPlatform();
@@ -81,7 +201,8 @@ namespace feature
     ForEachFromDatRawFormat(tempDatFilePath, midPoints);
 
     // sort features by their middle point
-    std::sort(midPoints.m_vec.begin(), midPoints.m_vec.end(), &SortMidPointsFunc);
+    if (bSort)
+      std::sort(midPoints.m_vec.begin(), midPoints.m_vec.end(), &SortMidPointsFunc);
 
     // store sorted features
     {
@@ -109,14 +230,9 @@ namespace feature
     }
 
     // remove old not-sorted dat file
-    if (removeOriginalFile)
-    {
-      FileWriter::DeleteFile(tempDatFilePath);
+    FileWriter::DeleteFile(tempDatFilePath);
 
-      FileWriter::DeleteFile(datFilePath + DATA_FILE_TAG);
-      FileWriter::DeleteFile(datFilePath + GEOMETRY_FILE_TAG);
-      FileWriter::DeleteFile(datFilePath + TRIANGLE_FILE_TAG);
-    }
+    FileWriter::DeleteFile(datFilePath + DATA_FILE_TAG);
 
     return true;
   }
diff --git a/indexer/indexer_tool/feature_sorter.hpp b/indexer/indexer_tool/feature_sorter.hpp
index dc8dcc439b..810f66b3d9 100644
--- a/indexer/indexer_tool/feature_sorter.hpp
+++ b/indexer/indexer_tool/feature_sorter.hpp
@@ -4,6 +4,7 @@
 
 namespace feature
 {
-  // sorts features in the given file by their mid points
-  bool SortDatFile(string const & datFile, bool removeOriginalFile = true);
+  /// Final generation of data from input feature-dat-file.
+  /// @param[in] bSort sorts features in the given file by their mid points
+  bool GenerateFinalFeatures(string const & datFile, bool bSort);
 }
diff --git a/indexer/indexer_tool/indexer_tool.cpp b/indexer/indexer_tool/indexer_tool.cpp
index f6bee64075..f59ebb768d 100644
--- a/indexer/indexer_tool/indexer_tool.cpp
+++ b/indexer/indexer_tool/indexer_tool.cpp
@@ -138,8 +138,8 @@ int main(int argc, char ** argv)
 
     if (FLAGS_sort_features)
     {
-      LOG(LINFO, ("Sorting features inside", datFile));
-      if (!feature::SortDatFile(datFile))
+      LOG(LINFO, ("Generating result features for ", datFile));
+      if (!feature::GenerateFinalFeatures(datFile, FLAGS_sort_features))
       {
         // If error - move to next bucket without index generation
         continue;
@@ -148,7 +148,7 @@ int main(int argc, char ** argv)
 
     if (FLAGS_generate_index)
     {
-      LOG(LINFO, ("Generating index for", datFile));
+      LOG(LINFO, ("Generating index for ", datFile));
       if (!indexer::BuildIndexFromDatFile(datFile, FLAGS_intermediate_data_path + FLAGS_output))
       {
         LOG(LCRITICAL, ("Error generating index."));