diff --git a/coding/point_coding.hpp b/coding/point_coding.hpp
index 745fe031d5..9e545230f9 100644
--- a/coding/point_coding.hpp
+++ b/coding/point_coding.hpp
@@ -70,6 +70,9 @@ uint8_t GetCoordBits(m2::RectD const & limitRect, double accuracy);
 // 3. If you need to temporarily store the point as an uint,
 //    you do not need the complexity of interleaving.
 //
+// By VNG: Well, for polys delta encoding WriteVarUint(BitwiseMerge(x, y)) is better than
+// WriteVarUint(x) + WriteVarUint(y) by 15%. Check CitiesBoundaries_Compression test with World V0 vs V1.
+//
 // Another possible reason to interleave bits of x and y arises
 // when implementing the Z-order curve but we have this
 // written elsewhere (see geometry/cellid.hpp).
diff --git a/geometry/calipers_box.cpp b/geometry/calipers_box.cpp
index 0a1ccb1b43..fc5e8ce3c4 100644
--- a/geometry/calipers_box.cpp
+++ b/geometry/calipers_box.cpp
@@ -16,9 +16,6 @@ namespace m2
 {
 namespace
 {
-static_assert(std::numeric_limits<double>::has_infinity, "");
-
-double constexpr kInf = std::numeric_limits<double>::infinity();
 
 // Checks whether (p1 - p) x (p2 - p) >= 0.
 bool IsCCWNeg(PointD const & p1, PointD const & p2, PointD const & p, double eps)
@@ -53,8 +50,8 @@ void ForEachRect(ConvexHull const & hull, Fn && fn)
       ++l;
 
     auto const oab = Ort(ab);
-    std::array<Line2D, 4> const lines = {{Line2D(hull.PointAt(i), ab), Line2D(hull.PointAt(j), oab),
-                                     Line2D(hull.PointAt(k), ab), Line2D(hull.PointAt(l), oab)}};
+    std::array<Line2D, 4> const lines = {Line2D(hull.PointAt(i), ab), Line2D(hull.PointAt(j), oab),
+                                         Line2D(hull.PointAt(k), ab), Line2D(hull.PointAt(l), oab)};
     std::vector<PointD> corners;
     for (size_t i = 0; i < lines.size(); ++i)
     {
@@ -67,10 +64,10 @@ void ForEachRect(ConvexHull const & hull, Fn && fn)
     if (corners.size() != 4)
       continue;
 
-    auto const it = min_element(corners.begin(), corners.end());
-    rotate(corners.begin(), it, corners.end());
+    auto const it = std::min_element(corners.begin(), corners.end());
+    std::rotate(corners.begin(), it, corners.end());
 
-    fn(corners);
+    fn(std::move(corners));
   }
 }
 }  // namespace
@@ -85,51 +82,79 @@ CalipersBox::CalipersBox(std::vector<PointD> const & points) : m_points({})
     return;
   }
 
-  double bestArea = kInf;
+  double bestArea = std::numeric_limits<double>::max();
   std::vector<PointD> bestPoints;
-  ForEachRect(hull, [&](std::vector<PointD> const & points) {
+  ForEachRect(hull, [&](std::vector<PointD> && points)
+  {
     ASSERT_EQUAL(points.size(), 4, ());
     double const area = GetPolygonArea(points.begin(), points.end());
     if (area < bestArea)
     {
       bestArea = area;
-      bestPoints = points;
+      bestPoints = std::move(points);
     }
   });
 
-  if (bestPoints.empty())
+  if (!bestPoints.empty())
   {
-    BoundingBox bbox(points);
-    auto const min = bbox.Min();
-    auto const max = bbox.Max();
-
-    auto const width = max.x - min.x;
-    auto const height = max.y - min.y;
-
-    m_points.resize(4);
-    m_points[0] = min;
-    m_points[1] = m_points[0] + PointD(width, 0);
-    m_points[2] = m_points[1] + PointD(0, height);
-    m_points[3] = m_points[0] + PointD(0, height);
-    return;
+    ASSERT_EQUAL(bestPoints.size(), 4, ());
+    m_points = std::move(bestPoints);
   }
+  else
+    m_points = BoundingBox(points).Points();
+}
 
-  ASSERT_EQUAL(bestPoints.size(), 4, ());
-  m_points = bestPoints;
+void CalipersBox::Deserialize(std::vector<PointD> && points)
+{
+  ASSERT_EQUAL(points.size(), 4, ());
+
+  // 1. Stable after ser-des.
+  m_points = std::move(points);
+  ASSERT(TestValid(), ());
+
+  // 2. Stable with input.
+//#ifdef DEBUG
+//  CalipersBox test(m_points);
+//  ASSERT(test.TestValid(), ());
+//  *this = std::move(test);
+//#endif
+}
+
+void CalipersBox::Normalize()
+{
+  m_points.erase(std::unique(m_points.begin(), m_points.end()), m_points.end());
+  if (m_points.size() == 3)
+  {
+    if (m_points.front() == m_points.back())
+      m_points.pop_back();
+    else
+      m_points.push_back(m_points.back());
+  }
+}
+
+bool CalipersBox::TestValid() const
+{
+  size_t const n = m_points.size();
+  for (size_t i = 0; i < n; ++i)
+  {
+    if (!IsCCWNeg(m_points[i], m_points[(i + 1) % n], m_points[(i + 2) % n], kEps))
+      return false;
+  }
+  return n > 0;
 }
 
 bool CalipersBox::HasPoint(PointD const & p, double eps) const
 {
   auto const n = m_points.size();
-
-  if (n == 0)
+  switch (n)
+  {
+  case 0:
     return false;
-
-  if (n == 1)
+  case 1:
     return AlmostEqualAbs(m_points[0], p, eps);
-
-  if (n == 2)
+  case 2:
     return IsPointOnSegmentEps(p, m_points[0], m_points[1], eps);
+  }
 
   for (size_t i = 0; i < n; ++i)
   {
diff --git a/geometry/calipers_box.hpp b/geometry/calipers_box.hpp
index ed49431d88..3121e0ba0f 100644
--- a/geometry/calipers_box.hpp
+++ b/geometry/calipers_box.hpp
@@ -25,6 +25,13 @@ public:
   CalipersBox() = default;
   explicit CalipersBox(std::vector<PointD> const & points);
 
+  // Used in CitiesBoundariesDecoder. Faster than ctor.
+  void Deserialize(std::vector<PointD> && points);
+  // Remove useless points in case of degenerate box. Used in unit tests.
+  void Normalize();
+
+  bool TestValid() const;
+
   std::vector<PointD> const & Points() const { return m_points; }
 
   bool HasPoint(PointD const & p) const { return HasPoint(p, kEps); }
diff --git a/geometry/convex_hull.cpp b/geometry/convex_hull.cpp
index 184e8c94c6..84eca849f6 100644
--- a/geometry/convex_hull.cpp
+++ b/geometry/convex_hull.cpp
@@ -33,16 +33,15 @@ std::vector<PointD> BuildConvexHull(std::vector<PointD> points, double eps)
 {
   base::SortUnique(points);
 
-  auto const n = points.size();
+  ASSERT(points.empty() || points.begin() == min_element(points.begin(), points.end()), ());
 
-  if (n < 2)
+  if (points.size() < 3)
     return points;
 
-  std::iter_swap(points.begin(), min_element(points.begin(), points.end()));
-
   auto const pivot = points[0];
 
-  std::sort(points.begin() + 1, points.end(), [&pivot, &eps](PointD const & lhs, PointD const & rhs) {
+  std::sort(points.begin() + 1, points.end(), [&pivot, &eps](PointD const & lhs, PointD const & rhs)
+  {
     if (IsCCW(lhs, rhs, pivot, eps))
       return true;
     if (IsCCW(rhs, lhs, pivot, eps))
diff --git a/indexer/cities_boundaries_serdes.hpp b/indexer/cities_boundaries_serdes.hpp
index 949db52cbe..410fb2998c 100644
--- a/indexer/cities_boundaries_serdes.hpp
+++ b/indexer/cities_boundaries_serdes.hpp
@@ -18,7 +18,6 @@
 
 #include "base/assert.hpp"
 #include "base/macros.hpp"
-#include "base/visitor.hpp"
 
 #include <algorithm>
 #include <cmath>
@@ -40,11 +39,13 @@ public:
     {
     }
 
-    void operator()(m2::PointD const & p) { return (*this)(ToU(p)); }
-
-    void operator()(m2::PointU const & p)
+    void Save(m2::PointU const & p)
     {
       WriteVarUint(m_sink, coding::EncodePointDeltaAsUint(p, m_last));
+    }
+    void SaveWithLast(m2::PointU const & p)
+    {
+      Save(p);
       m_last = p;
     }
 
@@ -53,7 +54,7 @@ public:
       auto const min = ToU(bbox.Min());
       auto const max = ToU(bbox.Max());
 
-      (*this)(min);
+      SaveWithLast(min);
       EncodeNonNegativePointDelta(min, max);
     }
 
@@ -84,9 +85,9 @@ public:
 
       auto const us = ToU(ps);
 
-      (*this)(us[0]);
-      coding::EncodePointDelta(m_sink, us[0], us[1]);
-      coding::EncodePointDelta(m_sink, us[0], us[3]);
+      SaveWithLast(us[0]);
+      Save(us[1]);
+      Save(us[3]);
     }
 
     void operator()(m2::DiamondBox const & dbox)
@@ -96,15 +97,17 @@ public:
       auto const next = ps[1];
       auto const prev = ps[3];
 
-      (*this)(base);
+      SaveWithLast(base);
 
       ASSERT_GREATER_OR_EQUAL(next.x, base.x, ());
       ASSERT_GREATER_OR_EQUAL(next.y, base.y, ());
-      WriteVarUint(m_sink, next.x >= base.x ? next.x - base.x : 0);
+      auto const nx = next.x >= base.x ? next.x - base.x : 0;
 
       ASSERT_GREATER_OR_EQUAL(prev.x, base.x, ());
       ASSERT_LESS_OR_EQUAL(prev.y, base.y, ());
-      WriteVarUint(m_sink, prev.x >= base.x ? prev.x - base.x : 0);
+      auto const px = prev.x >= base.x ? prev.x - base.x : 0;
+
+      WriteVarUint(m_sink, bits::BitwiseMerge(nx, px));
     }
 
     template <typename R>
@@ -141,8 +144,7 @@ public:
       // here. In general, next.x >= curr.x and next.y >= curr.y.
       auto const dx = next.x >= curr.x ? next.x - curr.x : 0;
       auto const dy = next.y >= curr.y ? next.y - curr.y : 0;
-      WriteVarUint(m_sink, dx);
-      WriteVarUint(m_sink, dy);
+      WriteVarUint(m_sink, bits::BitwiseMerge(dx, dy));
     }
 
     Sink & m_sink;
@@ -184,10 +186,40 @@ private:
 };
 
 template <typename Source>
-class CitiesBoundariesDecoderV0
+class CitiesBoundariesDecoder
 {
 public:
-  struct Visitor
+  struct DecoderV0
+  {
+    static m2::PointU DecodeNonNegativeDelta(Source & src)
+    {
+      auto const dx = ReadVarUint<uint32_t>(src);
+      auto const dy = ReadVarUint<uint32_t>(src);
+      return {dx, dy};
+    }
+
+    static m2::PointU DecodePoint(Source & src, m2::PointU const & base)
+    {
+      return coding::DecodePointDelta(src, base);
+    }
+  };
+
+  struct DecoderV1
+  {
+    static m2::PointU DecodeNonNegativeDelta(Source & src)
+    {
+      uint32_t dx, dy;
+      bits::BitwiseSplit(ReadVarUint<uint64_t>(src), dx, dy);
+      return {dx, dy};
+    }
+
+    static m2::PointU DecodePoint(Source & src, m2::PointU const & base)
+    {
+      return coding::DecodePointDeltaFromUint(ReadVarUint<uint64_t>(src), base);
+    }
+  };
+
+  template <class TDecoder> struct Visitor
   {
   public:
     Visitor(Source & source, serial::GeometryCodingParams const & params)
@@ -195,57 +227,53 @@ public:
     {
     }
 
-    void operator()(m2::PointD & p)
+    m2::PointU LoadPoint()
     {
-      m2::PointU u;
-      (*this)(u);
-      p = FromU(u);
+      return coding::DecodePointDeltaFromUint(ReadVarUint<uint64_t>(m_source), m_last);
     }
 
-    void operator()(m2::PointU & p)
+    m2::PointU LoadPointWithLast()
     {
-      p = coding::DecodePointDeltaFromUint(ReadVarUint<uint64_t>(m_source), m_last);
-      m_last = p;
+      m_last = LoadPoint();
+      return m_last;
     }
 
     void operator()(m2::BoundingBox & bbox)
     {
-      m2::PointU min;
-      (*this)(min);
-      auto const max = DecodeNonNegativePointDelta(min);
+      auto const min = LoadPointWithLast();
+      m2::PointU const delta = TDecoder::DecodeNonNegativeDelta(m_source);
 
       bbox = m2::BoundingBox();
       bbox.Add(FromU(min));
-      bbox.Add(FromU(max));
+      bbox.Add(FromU(min + delta));
     }
 
     void operator()(m2::CalipersBox & cbox)
     {
       std::vector<m2::PointU> us(4);
-      (*this)(us[0]);
-      us[1] = coding::DecodePointDelta(m_source, us[0]);
-      us[3] = coding::DecodePointDelta(m_source, us[0]);
+      us[0] = LoadPointWithLast();
+      us[1] = TDecoder::DecodePoint(m_source, m_last);
+      us[3] = TDecoder::DecodePoint(m_source, m_last);
 
       auto ps = FromU(us);
       auto const dp = ps[3] - ps[0];
       ps[2] = ps[1] + dp;
 
-      cbox = m2::CalipersBox(ps);
+      cbox.Deserialize(std::move(ps));
     }
 
     void operator()(m2::DiamondBox & dbox)
     {
-      m2::PointU base;
-      (*this)(base);
+      auto const base = LoadPointWithLast();
 
-      auto const nx = ReadVarUint<uint32_t>(m_source);
-      auto const px = ReadVarUint<uint32_t>(m_source);
+      // {nx, px}
+      auto const delta = TDecoder::DecodeNonNegativeDelta(m_source);
 
       dbox = m2::DiamondBox();
       dbox.Add(FromU(base));
-      dbox.Add(FromU(base + m2::PointU(nx, nx)));
-      dbox.Add(FromU(base + m2::PointU(px, -px)));
-      dbox.Add(FromU(base + m2::PointU(nx + px, nx - px)));
+      dbox.Add(FromU(base + m2::PointU(delta.x, delta.x)));
+      dbox.Add(FromU(base + m2::PointU(delta.y, -delta.y)));
+      dbox.Add(FromU(base + m2::PointU(delta.x + delta.y, delta.x - delta.y)));
     }
 
     template <typename R>
@@ -268,122 +296,82 @@ public:
       return ps;
     }
 
-    // Reads the encoded difference from |m_source| and returns the
-    // point equal to |base| + difference. It is guaranteed that
-    // both coordinates of difference are non-negative.
-    m2::PointU DecodeNonNegativePointDelta(m2::PointU const & base)
-    {
-      auto const dx = ReadVarUint<uint32_t>(m_source);
-      auto const dy = ReadVarUint<uint32_t>(m_source);
-      return m2::PointU(base.x + dx, base.y + dy);
-    }
-
     Source & m_source;
     serial::GeometryCodingParams const m_params;
     m2::PointU m_last;
   };
 
-  CitiesBoundariesDecoderV0(Source & source, serial::GeometryCodingParams const & params)
-    : m_source(source), m_visitor(source, params)
+  using BoundariesT = std::vector<std::vector<CityBoundary>>;
+
+  CitiesBoundariesDecoder(Source & source, serial::GeometryCodingParams const & params, BoundariesT & res)
+    : m_source(source), m_params(params), m_boundaries(res)
   {
   }
 
-  void operator()(std::vector<std::vector<CityBoundary>> & boundaries)
+  void LoadSizes()
   {
     {
       auto const size = static_cast<size_t>(ReadVarUint<uint64_t>(m_source));
-      boundaries.resize(size);
-    }
+      m_boundaries.resize(size);
 
-    {
       BitReader<Source> reader(m_source);
-      for (auto & bs : boundaries)
+      for (auto & bs : m_boundaries)
       {
         auto const size = static_cast<size_t>(coding::GammaCoder::Decode(reader));
         ASSERT_GREATER_OR_EQUAL(size, 1, ());
         bs.resize(size - 1);
       }
     }
+  }
 
-    for (auto & bs : boundaries)
+  template <class TDecoder> void LoadBoundaries()
+  {
+    Visitor<TDecoder> visitor(m_source, m_params);
+    for (auto & bs : m_boundaries)
     {
       for (auto & b : bs)
-        m_visitor(b);
+        visitor(b);
     }
   }
 
 private:
   Source & m_source;
-  Visitor m_visitor;
+  serial::GeometryCodingParams const m_params;
+  BoundariesT & m_boundaries;
 };
 
 struct CitiesBoundariesSerDes
 {
-  template <typename Sink>
-  struct WriteToSinkVisitor
+  struct Header
   {
-    WriteToSinkVisitor(Sink & sink) : m_sink(sink) {}
-
-    template <typename T>
-    std::enable_if_t<std::is_integral<T>::value || std::is_enum<T>::value, void> operator()(
-        T const & t, char const * /* name */ = nullptr)
-    {
-      WriteToSink(m_sink, t);
-    }
-
-    template <typename T>
-    std::enable_if_t<!std::is_integral<T>::value && !std::is_enum<T>::value, void> operator()(
-        T const & t, char const * /* name */ = nullptr)
-    {
-      t.Visit(*this);
-    }
-
-    Sink & m_sink;
-  };
-
-  template <typename Source>
-  struct ReadFromSourceVisitor
-  {
-    ReadFromSourceVisitor(Source & source) : m_source(source) {}
-
-    template <typename T>
-    std::enable_if_t<std::is_integral<T>::value || std::is_enum<T>::value, void> operator()(
-        T & t, char const * /* name */ = nullptr)
-    {
-      t = ReadPrimitiveFromSource<T>(m_source);
-    }
-
-    template <typename T>
-    std::enable_if_t<!std::is_integral<T>::value && !std::is_enum<T>::value, void> operator()(
-        T & t, char const * /* name */ = nullptr)
-    {
-      t.Visit(*this);
-    }
-
-    Source & m_source;
-  };
-
-  static uint8_t constexpr kLatestVersion = 0;
-
-  struct HeaderV0
-  {
-    static uint8_t const kDefaultCoordBits = 19;
-
-    DECLARE_VISITOR(visitor(m_coordBits, "coordBits"))
+    // 0 - initial version
+    // 1 - optimized delta-points encoding
+    static uint8_t constexpr kLatestVersion = 1;
+    static uint8_t constexpr kDefaultCoordBits = 19;
 
     uint8_t m_coordBits = kDefaultCoordBits;
+    uint8_t m_version = kLatestVersion;
+
+    template <class Sink> void Serialize(Sink & sink) const
+    {
+      WriteToSink(sink, m_version);
+      WriteToSink(sink, m_coordBits);
+    }
+
+    template <class Source> void Deserialize(Source & src)
+    {
+      m_version = ReadPrimitiveFromSource<uint8_t>(src);
+      m_coordBits = ReadPrimitiveFromSource<uint8_t>(src);
+    }
   };
 
+  using BoundariesT = std::vector<std::vector<CityBoundary>>;
+
   template <typename Sink>
-  static void Serialize(Sink & sink, std::vector<std::vector<CityBoundary>> const & boundaries)
+  static void Serialize(Sink & sink, BoundariesT const & boundaries)
   {
-    uint8_t const version = kLatestVersion;
-
-    WriteToSinkVisitor<Sink> visitor(sink);
-    visitor(version);
-
-    HeaderV0 const header;
-    visitor(header);
+    Header header;
+    header.Serialize(sink);
 
     using mercator::Bounds;
     serial::GeometryCodingParams const params(header.m_coordBits, {Bounds::kMinX, Bounds::kMinY});
@@ -392,25 +380,24 @@ struct CitiesBoundariesSerDes
   }
 
   template <typename Source>
-  static void Deserialize(Source & source, std::vector<std::vector<CityBoundary>> & boundaries,
-                          double & precision)
+  static void Deserialize(Source & source, BoundariesT & boundaries, double & precision)
   {
-    ReadFromSourceVisitor<Source> visitor(source);
-
-    uint8_t version;
-    visitor(version);
-
-    CHECK_EQUAL(version, 0, ());
-
-    HeaderV0 header;
-    visitor(header);
+    Header header;
+    header.Deserialize(source);
 
     using mercator::Bounds;
     precision = std::max(Bounds::kRangeX, Bounds::kRangeY) / double(1 << header.m_coordBits);
 
     serial::GeometryCodingParams const params(header.m_coordBits, {Bounds::kMinX, Bounds::kMinY});
-    CitiesBoundariesDecoderV0<Source> decoder(source, params);
-    decoder(boundaries);
+    using DecoderT = CitiesBoundariesDecoder<Source>;
+    DecoderT decoder(source, params, boundaries);
+
+    decoder.LoadSizes();
+    if (header.m_version == 0)
+      decoder.template LoadBoundaries<typename DecoderT::DecoderV0>();
+    else
+      decoder.template LoadBoundaries<typename DecoderT::DecoderV1>();
   }
 };
-}  // namespace indexer
+
+} // namespace indexer
diff --git a/indexer/indexer_tests/cities_boundaries_serdes_tests.cpp b/indexer/indexer_tests/cities_boundaries_serdes_tests.cpp
index 743126f49d..fcd227ced2 100644
--- a/indexer/indexer_tests/cities_boundaries_serdes_tests.cpp
+++ b/indexer/indexer_tests/cities_boundaries_serdes_tests.cpp
@@ -3,30 +3,27 @@
 #include "indexer/cities_boundaries_serdes.hpp"
 #include "indexer/city_boundary.hpp"
 
-#include "coding/geometry_coding.hpp"
+#include "platform/platform.hpp"
+
+#include "coding/files_container.hpp"
 #include "coding/reader.hpp"
 #include "coding/writer.hpp"
 
-#include "geometry/mercator.hpp"
 #include "geometry/point2d.hpp"
 
-#include <cstdint>
-#include <utility>
+#include "base/file_name_utils.hpp"
+
 #include <vector>
 
+namespace cities_boundaries_serdes_tests
+{
 using namespace indexer;
 using namespace m2;
-using namespace serial;
 using namespace std;
 
-namespace
-{
 using Boundary = vector<CityBoundary>;
 using Boundaries = vector<Boundary>;
 
-static_assert(CitiesBoundariesSerDes::kLatestVersion == 0, "");
-static_assert(CitiesBoundariesSerDes::HeaderV0::kDefaultCoordBits == 19, "");
-
 struct Result
 {
   Result(Boundaries const & boundaries, double eps) : m_boundaries(boundaries), m_eps(eps) {}
@@ -50,7 +47,11 @@ void TestEqual(BoundingBox const & lhs, BoundingBox const & rhs, double eps)
 
 void TestEqual(CalipersBox const & lhs, CalipersBox const & rhs, double eps)
 {
-  TestEqual(lhs.Points(), rhs.Points(), eps);
+  // SerDes for CaliperBox works without normalization.
+  CalipersBox norm(rhs);
+  norm.Normalize();
+
+  TestEqual(lhs.Points(), norm.Points(), eps);
 }
 
 void TestEqual(DiamondBox const & lhs, DiamondBox const & rhs, double eps)
@@ -76,6 +77,7 @@ void TestEqual(Boundary const & lhs, Boundary const & rhs, double eps)
     TestEqual(lhs[i], rhs[i], eps);
 }
 
+// Eps equal function to compare initial (expected) value (lhs) with encoded-decoded (rhs).
 void TestEqual(Boundaries const & lhs, Boundaries const & rhs, double eps)
 {
   TEST_EQUAL(lhs.size(), rhs.size(), (lhs, rhs));
@@ -130,12 +132,11 @@ UNIT_TEST(CitiesBoundariesSerDes_Smoke)
 
 UNIT_TEST(CitiesBoundaries_Moscow)
 {
-  vector<m2::PointD> const points = {{37.04001, 67.55964},
-                                     {37.55650, 66.96428},
-                                     {38.02513, 67.37082},
-                                     {37.50865, 67.96618}};
+  vector<PointD> const points = {
+    {37.04001, 67.55964}, {37.55650, 66.96428}, {38.02513, 67.37082}, {37.50865, 67.96618}
+  };
 
-  m2::PointD const target(37.44765, 67.65243);
+  PointD const target(37.44765, 67.65243);
 
   vector<uint8_t> buffer;
   {
@@ -159,4 +160,40 @@ UNIT_TEST(CitiesBoundaries_Moscow)
     TEST(boundaries[0][0].HasPoint(target, precision), ());
   }
 }
-}  // namespace
+
+UNIT_TEST(CitiesBoundaries_Compression)
+{
+  FilesContainerR cont(base::JoinPath(GetPlatform().WritableDir(), WORLD_FILE_NAME) + DATA_FILE_EXTENSION);
+
+  vector<vector<CityBoundary>> all1;
+  double precision;
+
+  ReaderSource source1(cont.GetReader(CITIES_BOUNDARIES_FILE_TAG));
+  LOG(LINFO, ("Size before:", source1.Size()));
+
+  CitiesBoundariesSerDes::Deserialize(source1, all1, precision);
+
+  vector<uint8_t> buffer;
+  MemWriter writer(buffer);
+  CitiesBoundariesSerDes::Serialize(writer, all1);
+  LOG(LINFO, ("Size after:", buffer.size()));
+
+  // Equal test.
+  vector<vector<CityBoundary>> all2;
+  MemReader reader(buffer.data(), buffer.size());
+  ReaderSource source2(reader);
+  CitiesBoundariesSerDes::Deserialize(source2, all2, precision);
+
+  TEST_EQUAL(all1.size(), all2.size(), ());
+  for (size_t i = 0; i < all1.size(); ++i)
+  {
+    TEST_EQUAL(all1[i].size(), all2[i].size(), ());
+    for (size_t j = 0; j < all1[i].size(); ++j)
+    {
+      if (!(all1[i][j] == all2[i][j]))
+        LOG(LINFO, (i, all1[i][j], all2[i][j]));
+    }
+  }
+}
+
+} // namespace cities_boundaries_serdes_tests