diff --git a/coding/CMakeLists.txt b/coding/CMakeLists.txt
index e9c5f80aa9..d07ad421f2 100644
--- a/coding/CMakeLists.txt
+++ b/coding/CMakeLists.txt
@@ -57,10 +57,8 @@ set(
   multilang_utf8_string.cpp
   multilang_utf8_string.hpp
   parse_xml.hpp
-  point_to_integer.cpp
-  point_to_integer.hpp
-  pointd_to_pointu.cpp
-  pointd_to_pointu.hpp
+  point_coding.cpp
+  point_coding.hpp
   polymorph_reader.hpp
   read_write_utils.hpp
   reader.cpp
diff --git a/coding/coding_tests/CMakeLists.txt b/coding/coding_tests/CMakeLists.txt
index 6955a79419..f8ee6ec16c 100644
--- a/coding/coding_tests/CMakeLists.txt
+++ b/coding/coding_tests/CMakeLists.txt
@@ -25,8 +25,7 @@ set(
   mem_file_writer_test.cpp
   multilang_utf8_string_test.cpp
   png_decoder_test.cpp
-  point_to_integer_test.cpp
-  pointd_to_pointu_tests.cpp
+  point_coding_tests.cpp
   reader_cache_test.cpp
   reader_test.cpp
   reader_test.hpp
diff --git a/coding/coding_tests/geometry_coding_test.cpp b/coding/coding_tests/geometry_coding_test.cpp
index d3caf8e5df..3e398a17b3 100644
--- a/coding/coding_tests/geometry_coding_test.cpp
+++ b/coding/coding_tests/geometry_coding_test.cpp
@@ -3,8 +3,7 @@
 #include "coding/byte_stream.hpp"
 #include "coding/coding_tests/test_polylines.hpp"
 #include "coding/geometry_coding.hpp"
-#include "coding/point_to_integer.hpp"
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/varint.hpp"
 #include "coding/writer.hpp"
 
@@ -23,7 +22,7 @@ namespace
 {
 m2::PointU D2U(m2::PointD const & p) { return PointDToPointU(p, POINT_COORD_BITS); }
 
-m2::PointU GetMaxPoint() { return D2U(m2::PointD(MercatorBounds::maxX, MercatorBounds::maxY)); }
+m2::PointU GetMaxPoint() { return D2U(m2::PointD(MercatorBounds::kMaxX, MercatorBounds::kMaxY)); }
 
 void TestPolylineEncode(string testName, vector<m2::PointU> const & points,
                         m2::PointU const & maxPoint,
diff --git a/coding/coding_tests/geometry_serialization_test.cpp b/coding/coding_tests/geometry_serialization_test.cpp
index 1aa9636ad2..6e858ab14a 100644
--- a/coding/coding_tests/geometry_serialization_test.cpp
+++ b/coding/coding_tests/geometry_serialization_test.cpp
@@ -14,12 +14,12 @@ namespace
 {
 bool is_equal(double d1, double d2)
 {
-  return (fabs(d1 - d2) < MercatorBounds::GetCellID2PointAbsEpsilon());
+  return (fabs(d1 - d2) < kCellIdToPointEps);
 }
 
 bool is_equal(m2::PointD const & p1, m2::PointD const & p2)
 {
-  return p1.EqualDxDy(p2, MercatorBounds::GetCellID2PointAbsEpsilon());
+  return p1.EqualDxDy(p2, kCellIdToPointEps);
 }
 
 bool is_equal(m2::RectD const & r1, m2::RectD const & r2)
diff --git a/coding/coding_tests/point_to_integer_test.cpp b/coding/coding_tests/point_coding_tests.cpp
similarity index 76%
rename from coding/coding_tests/point_to_integer_test.cpp
rename to coding/coding_tests/point_coding_tests.cpp
index 2842fedfdf..d5a0a8dc96 100644
--- a/coding/coding_tests/point_to_integer_test.cpp
+++ b/coding/coding_tests/point_coding_tests.cpp
@@ -1,8 +1,8 @@
 #include "testing/testing.hpp"
 
 #include "coding/coding_tests/test_polylines.hpp"
-#include "coding/point_to_integer.hpp"
-#include "coding/pointd_to_pointu.hpp"
+
+#include "coding/point_coding.hpp"
 
 #include "geometry/mercator.hpp"
 
@@ -14,7 +14,7 @@ using namespace std;
 
 namespace
 {
-double const kEps = MercatorBounds::GetCellID2PointAbsEpsilon();
+double const kEps = kCellIdToPointEps;
 uint32_t const kCoordBits = POINT_COORD_BITS;
 uint32_t const kBig = uint32_t{1} << 30;
 
@@ -34,6 +34,44 @@ void CheckEqualPoints(m2::PointD const & p1, m2::PointD const & p2)
 }
 }  // namespace
 
+UNIT_TEST(PointDToPointU_Epsilons)
+{
+  m2::PointD const arrPt[] = {{-180, -180}, {-180, 180}, {180, 180}, {180, -180}};
+  m2::PointD const arrD[] = {{1, 1}, {1, -1}, {-1, -1}, {-1, 1}};
+  size_t const count = ARRAY_SIZE(arrPt);
+
+  double eps = 1.0;
+  while (true)
+  {
+    size_t i = 0;
+    for (; i < count; ++i)
+    {
+      m2::PointU p0 = PointDToPointU(arrPt[i].x, arrPt[i].y, kCoordBits);
+      m2::PointU p1 = PointDToPointU(arrPt[i].x + arrD[i].x * eps,
+                                     arrPt[i].y + arrD[i].y * eps,
+                                     kCoordBits);
+
+      if (p0 != p1)
+        break;
+    }
+    if (i == count)
+      break;
+
+    eps *= 0.1;
+  }
+
+  LOG(LINFO, ("Epsilon (relative error) =", eps));
+
+  for (size_t i = 0; i < count; ++i)
+  {
+    m2::PointU const p1 = PointDToPointU(arrPt[i].x, arrPt[i].y, kCoordBits);
+    m2::PointU const p2(p1.x + arrD[i].x, p1.y + arrD[i].y);
+    m2::PointD const p3 = PointUToPointD(p2, kCoordBits);
+
+    LOG(LINFO, ("Dx =", p3.x - arrPt[i].x, "Dy =", p3.y - arrPt[i].y));
+  }
+}
+
 UNIT_TEST(PointToInt64Obsolete_Smoke)
 {
   m2::PointD const arr[] = {{1.25, 1.3}, {180, 90}, {-180, -90}, {0, 0}};
@@ -112,7 +150,7 @@ UNIT_TEST(PointUToUint64Obsolete_1bit)
   TEST_EQUAL((1ULL << 60) - 1, PointUToUint64Obsolete(m2::PointU(kBig - 1, kBig - 1)), ());
 }
 
-UNIT_TEST(PointToInt64_DataSet1)
+UNIT_TEST(PointToInt64Obsolete_DataSet1)
 {
   using namespace geometry_coding_tests;
 
diff --git a/coding/coding_tests/pointd_to_pointu_tests.cpp b/coding/coding_tests/pointd_to_pointu_tests.cpp
deleted file mode 100644
index 606403b69d..0000000000
--- a/coding/coding_tests/pointd_to_pointu_tests.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "testing/testing.hpp"
-
-#include "coding/pointd_to_pointu.hpp"
-
-#include "base/logging.hpp"
-
-#include <cmath>
-
-using namespace std;
-
-namespace
-{
-uint32_t const kCoordBits = POINT_COORD_BITS;
-}  // namespace
-
-UNIT_TEST(PointDToPointU_Epsilons)
-{
-  m2::PointD const arrPt[] = {{-180, -180}, {-180, 180}, {180, 180}, {180, -180}};
-  m2::PointD const arrD[] = {{1, 1}, {1, -1}, {-1, -1}, {-1, 1}};
-  size_t const count = ARRAY_SIZE(arrPt);
-
-  double eps = 1.0;
-  while (true)
-  {
-    size_t i = 0;
-    for (; i < count; ++i)
-    {
-      m2::PointU p0 = PointDToPointU(arrPt[i].x, arrPt[i].y, kCoordBits);
-      m2::PointU p1 = PointDToPointU(arrPt[i].x + arrD[i].x * eps,
-                                    arrPt[i].y + arrD[i].y * eps,
-                                    kCoordBits);
-
-      if (p0 != p1)
-        break;
-    }
-    if (i == count)
-      break;
-
-    eps *= 0.1;
-  }
-
-  LOG(LINFO, ("Epsilon (relative error) =", eps));
-
-  for (size_t i = 0; i < count; ++i)
-  {
-    m2::PointU const p1 = PointDToPointU(arrPt[i].x, arrPt[i].y, kCoordBits);
-    m2::PointU const p2(p1.x + arrD[i].x, p1.y + arrD[i].y);
-    m2::PointD const p3 = PointUToPointD(p2, kCoordBits);
-
-    LOG(LINFO, ("Dx =", p3.x - arrPt[i].x, "Dy =", p3.y - arrPt[i].y));
-  }
-}
diff --git a/coding/geometry_coding.cpp b/coding/geometry_coding.cpp
index e6e821bce8..6dd2cd2ccb 100644
--- a/coding/geometry_coding.cpp
+++ b/coding/geometry_coding.cpp
@@ -1,6 +1,6 @@
 #include "coding/geometry_coding.hpp"
 
-#include "coding/point_to_integer.hpp"
+#include "coding/point_coding.hpp"
 
 #include "geometry/mercator.hpp"
 
@@ -326,14 +326,14 @@ m2::PointU D2U(m2::PointD const & p, uint32_t coordBits) { return PointDToPointU
 m2::PointD U2D(m2::PointU const & p, uint32_t coordBits)
 {
   m2::PointD const pt = PointUToPointD(p, coordBits);
-  ASSERT(MercatorBounds::minX <= pt.x && pt.y <= MercatorBounds::maxX, (p, pt, coordBits));
-  ASSERT(MercatorBounds::minY <= pt.x && pt.y <= MercatorBounds::maxY, (p, pt, coordBits));
+  ASSERT(MercatorBounds::kMinX <= pt.x && pt.y <= MercatorBounds::kMaxX, (p, pt, coordBits));
+  ASSERT(MercatorBounds::kMinY <= pt.x && pt.y <= MercatorBounds::kMaxY, (p, pt, coordBits));
   return pt;
 }
 
 m2::PointU GetMaxPoint(GeometryCodingParams const & params)
 {
-  return D2U(m2::PointD(MercatorBounds::maxX, MercatorBounds::maxY), params.GetCoordBits());
+  return D2U(m2::PointD(MercatorBounds::kMaxX, MercatorBounds::kMaxY), params.GetCoordBits());
 }
 
 m2::PointU GetBasePoint(GeometryCodingParams const & params) { return params.GetBasePoint(); }
diff --git a/coding/geometry_coding.hpp b/coding/geometry_coding.hpp
index 26b8db04e4..28f7869f32 100644
--- a/coding/geometry_coding.hpp
+++ b/coding/geometry_coding.hpp
@@ -2,7 +2,7 @@
 
 #include "geometry/point2d.hpp"
 
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/tesselator_decl.hpp"
 #include "coding/varint.hpp"
 #include "coding/writer.hpp"
diff --git a/coding/point_coding.cpp b/coding/point_coding.cpp
new file mode 100644
index 0000000000..bb65162750
--- /dev/null
+++ b/coding/point_coding.cpp
@@ -0,0 +1,109 @@
+#include "coding/point_coding.hpp"
+
+#include "geometry/mercator.hpp"
+
+#include "base/assert.hpp"
+#include "base/bits.hpp"
+#include "base/math.hpp"
+
+namespace
+{
+double CoordSize(uint32_t coordBits) { return (1 << coordBits) - 1; }
+}  // namespace
+
+uint32_t DoubleToUint32(double x, double min, double max, uint32_t coordBits)
+{
+  ASSERT_GREATER_OR_EQUAL(coordBits, 1, ());
+  ASSERT_LESS_OR_EQUAL(coordBits, 32, ());
+  x = base::clamp(x, min, max);
+  uint64_t const fullMask = bits::GetFullMask(static_cast<uint8_t>(coordBits));
+  return static_cast<uint32_t>(0.5 + (x - min) / (max - min) * fullMask);
+}
+
+double Uint32ToDouble(uint32_t x, double min, double max, uint32_t coordBits)
+{
+  ASSERT_GREATER_OR_EQUAL(coordBits, 1, ());
+  ASSERT_LESS_OR_EQUAL(coordBits, 32, ());
+  return min +
+         static_cast<double>(x) * (max - min) / bits::GetFullMask(static_cast<uint8_t>(coordBits));
+}
+
+m2::PointU PointDToPointU(double x, double y, uint32_t coordBits)
+{
+  x = base::clamp(x, MercatorBounds::kMinX, MercatorBounds::kMaxX);
+  y = base::clamp(y, MercatorBounds::kMinY, MercatorBounds::kMaxY);
+
+  uint32_t const ix = static_cast<uint32_t>(
+      0.5 + (x - MercatorBounds::kMinX) / MercatorBounds::kRangeX * CoordSize(coordBits));
+  uint32_t const iy = static_cast<uint32_t>(
+      0.5 + (y - MercatorBounds::kMinY) / MercatorBounds::kRangeY * CoordSize(coordBits));
+
+  ASSERT_LESS_OR_EQUAL(ix, CoordSize(coordBits), ());
+  ASSERT_LESS_OR_EQUAL(iy, CoordSize(coordBits), ());
+
+  return m2::PointU(ix, iy);
+}
+
+m2::PointU PointDToPointU(m2::PointD const & pt, uint32_t coordBits)
+{
+  return PointDToPointU(pt.x, pt.y, coordBits);
+}
+
+m2::PointD PointUToPointD(m2::PointU const & pt, uint32_t coordBits)
+{
+  return m2::PointD(static_cast<double>(pt.x) * MercatorBounds::kRangeX / CoordSize(coordBits) +
+                        MercatorBounds::kMinX,
+                    static_cast<double>(pt.y) * MercatorBounds::kRangeY / CoordSize(coordBits) +
+                        MercatorBounds::kMinY);
+}
+
+// Obsolete functions ------------------------------------------------------------------------------
+
+int64_t PointToInt64Obsolete(double x, double y, uint32_t coordBits)
+{
+  int64_t const res = static_cast<int64_t>(PointUToUint64Obsolete(PointDToPointU(x, y, coordBits)));
+
+  ASSERT_GREATER_OR_EQUAL(res, 0, ("Highest bits of (ix, iy) are not used, so res should be > 0."));
+  ASSERT_LESS_OR_EQUAL(static_cast<uint64_t>(res), uint64_t{3} << 2 * POINT_COORD_BITS, ());
+  return res;
+}
+
+int64_t PointToInt64Obsolete(m2::PointD const & pt, uint32_t coordBits)
+{
+  return PointToInt64Obsolete(pt.x, pt.y, coordBits);
+}
+
+m2::PointD Int64ToPointObsolete(int64_t v, uint32_t coordBits)
+{
+  ASSERT_GREATER_OR_EQUAL(v, 0, ("Highest bits of (ix, iy) are not used, so res should be > 0."));
+  ASSERT_LESS_OR_EQUAL(static_cast<uint64_t>(v), uint64_t{3} << 2 * POINT_COORD_BITS, ());
+  return PointUToPointD(Uint64ToPointUObsolete(static_cast<uint64_t>(v)), coordBits);
+}
+
+std::pair<int64_t, int64_t> RectToInt64Obsolete(m2::RectD const & r, uint32_t coordBits)
+{
+  int64_t const p1 = PointToInt64Obsolete(r.minX(), r.minY(), coordBits);
+  int64_t const p2 = PointToInt64Obsolete(r.maxX(), r.maxY(), coordBits);
+  return std::make_pair(p1, p2);
+}
+
+m2::RectD Int64ToRectObsolete(std::pair<int64_t, int64_t> const & p, uint32_t coordBits)
+{
+  m2::PointD const pt1 = Int64ToPointObsolete(p.first, coordBits);
+  m2::PointD const pt2 = Int64ToPointObsolete(p.second, coordBits);
+  return m2::RectD(pt1, pt2);
+}
+
+uint64_t PointUToUint64Obsolete(m2::PointU const & pt)
+{
+  uint64_t const res = bits::BitwiseMerge(pt.x, pt.y);
+  ASSERT_EQUAL(pt, Uint64ToPointUObsolete(res), ());
+  return res;
+}
+
+m2::PointU Uint64ToPointUObsolete(int64_t v)
+{
+  m2::PointU res;
+  bits::BitwiseSplit(v, res.x, res.y);
+  return res;
+}
diff --git a/coding/point_coding.hpp b/coding/point_coding.hpp
new file mode 100644
index 0000000000..c8dd7e930d
--- /dev/null
+++ b/coding/point_coding.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include "geometry/point2d.hpp"
+#include "geometry/rect2d.hpp"
+
+#include <cstdint>
+#include <utility>
+
+#define POINT_COORD_BITS 30
+
+// The absolute precision of the point encoding in the mwm files.
+// If both x and y coordinates of two points lie within |kMwmPointAccuracy| of one
+// another we consider the points equal. In other words, |kMwmPointAccuracy| may
+// be used as the eps value for both x and y in Point::EqualDxDy, base::AlmostEqualAbs and such.
+//
+// The constant is loosely tied to MercatorBounds::kRangeX / (1 << POINT_COORD_BITS):
+//   The range of possible values for point coordinates
+//      MercatorBounds::kRangeX = 360.0
+//   The number of distinct values for each coordinate after encoding
+//      (1 << POINT_COORD_BITS) = 1073741824 ≈ 1e9
+//   Distance between two discernible points in the uniform case
+//      360.0 / 1e9 ≈ 4e-7 ≈ 0.04 * |kMwmPointAccuracy|.
+//
+// On the other hand, this should be enough for most purposes because
+// 1e-5 difference in the coordinates of a mercator-proected point corresponds to roughly
+// 1 meter difference on the equator and we do not expect most OSM points to be mapped
+// with better precision.
+//
+// todo(@m) By this argument, it seems that 1e-6 is a better choice.
+double constexpr kMwmPointAccuracy = 1e-5;
+
+// todo(@m) Explain this constant.
+double constexpr kCellIdToPointEps = 1e-4;
+
+uint32_t DoubleToUint32(double x, double min, double max, uint32_t coordBits);
+
+double Uint32ToDouble(uint32_t x, double min, double max, uint32_t coordBits);
+
+m2::PointU PointDToPointU(double x, double y, uint32_t coordBits);
+
+m2::PointU PointDToPointU(m2::PointD const & pt, uint32_t coordBits);
+
+m2::PointD PointUToPointD(m2::PointU const & p, uint32_t coordBits);
+
+// All functions below are deprecated and are left
+// only for backward compatibility.
+//
+// Their intention was to store a point with unsigned 32-bit integer
+// coordinates to a signed or to an unsigned 64-bit integer by interleaving the
+// bits of the point's coordinates.
+//
+// A possible reason for interleaving is to lower the number of bytes
+// needed by the varint encoding, at least if the coordinates are of the
+// same order of magnitude. However, this is hard to justify:
+// 1. We have no reason to expect the coordinates to be of the same order.
+// 2. If you need to serialize a point, doing it separately
+//    for each coordinate is almost always a better option.
+// 3. If you need to temporarily store the point as an uint,
+//    you do not need the complexity of interleaving.
+//
+// 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).
+
+int64_t PointToInt64Obsolete(double x, double y, uint32_t coordBits);
+
+int64_t PointToInt64Obsolete(m2::PointD const & pt, uint32_t coordBits);
+
+m2::PointD Int64ToPointObsolete(int64_t v, uint32_t coordBits);
+
+std::pair<int64_t, int64_t> RectToInt64Obsolete(m2::RectD const & r, uint32_t coordBits);
+
+m2::RectD Int64ToRectObsolete(std::pair<int64_t, int64_t> const & p, uint32_t coordBits);
+
+uint64_t PointUToUint64Obsolete(m2::PointU const & pt);
+
+m2::PointU Uint64ToPointUObsolete(int64_t v);
diff --git a/coding/point_to_integer.cpp b/coding/point_to_integer.cpp
deleted file mode 100644
index 2e809e7bf1..0000000000
--- a/coding/point_to_integer.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "coding/point_to_integer.hpp"
-
-#include "base/assert.hpp"
-#include "base/bits.hpp"
-
-int64_t PointToInt64Obsolete(double x, double y, uint32_t coordBits)
-{
-  int64_t const res = static_cast<int64_t>(PointUToUint64Obsolete(PointDToPointU(x, y, coordBits)));
-
-  ASSERT_GREATER_OR_EQUAL(res, 0, ("Highest bits of (ix, iy) are not used, so res should be > 0."));
-  ASSERT_LESS_OR_EQUAL(static_cast<uint64_t>(res), uint64_t{3} << 2 * POINT_COORD_BITS, ());
-  return res;
-}
-
-int64_t PointToInt64Obsolete(m2::PointD const & pt, uint32_t coordBits)
-{
-  return PointToInt64Obsolete(pt.x, pt.y, coordBits);
-}
-
-m2::PointD Int64ToPointObsolete(int64_t v, uint32_t coordBits)
-{
-  ASSERT_GREATER_OR_EQUAL(v, 0, ("Highest bits of (ix, iy) are not used, so res should be > 0."));
-  ASSERT_LESS_OR_EQUAL(static_cast<uint64_t>(v), uint64_t{3} << 2 * POINT_COORD_BITS, ());
-  return PointUToPointD(Uint64ToPointUObsolete(static_cast<uint64_t>(v)), coordBits);
-}
-
-std::pair<int64_t, int64_t> RectToInt64Obsolete(m2::RectD const & r, uint32_t coordBits)
-{
-  int64_t const p1 = PointToInt64Obsolete(r.minX(), r.minY(), coordBits);
-  int64_t const p2 = PointToInt64Obsolete(r.maxX(), r.maxY(), coordBits);
-  return std::make_pair(p1, p2);
-}
-
-m2::RectD Int64ToRectObsolete(std::pair<int64_t, int64_t> const & p, uint32_t coordBits)
-{
-  m2::PointD const pt1 = Int64ToPointObsolete(p.first, coordBits);
-  m2::PointD const pt2 = Int64ToPointObsolete(p.second, coordBits);
-  return m2::RectD(pt1, pt2);
-}
-
-uint64_t PointUToUint64Obsolete(m2::PointU const & pt)
-{
-  uint64_t const res = bits::BitwiseMerge(pt.x, pt.y);
-  ASSERT_EQUAL(pt, Uint64ToPointUObsolete(res), ());
-  return res;
-}
-
-m2::PointU Uint64ToPointUObsolete(int64_t v)
-{
-  m2::PointU res;
-  bits::BitwiseSplit(v, res.x, res.y);
-  return res;
-}
diff --git a/coding/point_to_integer.hpp b/coding/point_to_integer.hpp
deleted file mode 100644
index 923ab971d4..0000000000
--- a/coding/point_to_integer.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-#include "coding/pointd_to_pointu.hpp"
-
-#include "geometry/point2d.hpp"
-#include "geometry/rect2d.hpp"
-
-#include <cstdint>
-#include <utility>
-
-// All functions in this file are deprecated and are left
-// only for backward compatibility.
-//
-// Their intention was to store a point with unsigned 32-bit integer
-// coordinates to a signed or to an unsigned 64-bit integer by interleaving the
-// bits of the point's coordinates.
-//
-// A possible reason for interleaving is to lower the number of bytes
-// needed by the varint encoding, at least if the coordinates are of the
-// same order of magnitude. However, this is hard to justify:
-// 1. We have no reason to expect the coordinates to be of the same order.
-// 2. If you need to serialize a point, doing it separately
-//    for each coordinate is almost always a better option.
-// 3. If you need to temporarily store the point as an uint,
-//    you do not need the complexity of interleaving.
-//
-// 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).
-
-int64_t PointToInt64Obsolete(double x, double y, uint32_t coordBits);
-
-int64_t PointToInt64Obsolete(m2::PointD const & pt, uint32_t coordBits);
-
-m2::PointD Int64ToPointObsolete(int64_t v, uint32_t coordBits);
-
-std::pair<int64_t, int64_t> RectToInt64Obsolete(m2::RectD const & r, uint32_t coordBits);
-
-m2::RectD Int64ToRectObsolete(std::pair<int64_t, int64_t> const & p, uint32_t coordBits);
-
-uint64_t PointUToUint64Obsolete(m2::PointU const & pt);
-
-m2::PointU Uint64ToPointUObsolete(int64_t v);
diff --git a/coding/pointd_to_pointu.cpp b/coding/pointd_to_pointu.cpp
deleted file mode 100644
index 7dd2593da1..0000000000
--- a/coding/pointd_to_pointu.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "coding/pointd_to_pointu.hpp"
-
-#include "geometry/mercator.hpp"
-
-#include "base/bits.hpp"
-#include "base/math.hpp"
-
-namespace
-{
-double CoordSize(uint32_t coordBits) { return (1 << coordBits) - 1; }
-}  // namespace
-
-uint32_t DoubleToUint32(double x, double min, double max, uint32_t coordBits)
-{
-  ASSERT_GREATER_OR_EQUAL(coordBits, 1, ());
-  ASSERT_LESS_OR_EQUAL(coordBits, 32, ());
-  x = base::clamp(x, min, max);
-  return static_cast<uint32_t>(0.5 + (x - min) / (max - min) * bits::GetFullMask(static_cast<uint8_t>(coordBits)));
-}
-
-double Uint32ToDouble(uint32_t x, double min, double max, uint32_t coordBits)
-{
-  ASSERT_GREATER_OR_EQUAL(coordBits, 1, ());
-  ASSERT_LESS_OR_EQUAL(coordBits, 32, ());
-  return min + static_cast<double>(x) * (max - min) / bits::GetFullMask(static_cast<uint8_t>(coordBits));
-}
-
-m2::PointU PointDToPointU(double x, double y, uint32_t coordBits)
-{
-  x = base::clamp(x, MercatorBounds::minX, MercatorBounds::maxX);
-  y = base::clamp(y, MercatorBounds::minY, MercatorBounds::maxY);
-
-  uint32_t const ix = static_cast<uint32_t>(0.5 +
-                                            (x - MercatorBounds::minX) /
-                                                (MercatorBounds::maxX - MercatorBounds::minX) *
-                                                CoordSize(coordBits));
-  uint32_t const iy = static_cast<uint32_t>(0.5 +
-                                            (y - MercatorBounds::minY) /
-                                                (MercatorBounds::maxY - MercatorBounds::minY) *
-                                                CoordSize(coordBits));
-
-  ASSERT_LESS_OR_EQUAL(ix, CoordSize(coordBits), ());
-  ASSERT_LESS_OR_EQUAL(iy, CoordSize(coordBits), ());
-
-  return m2::PointU(ix, iy);
-}
-
-m2::PointU PointDToPointU(m2::PointD const & pt, uint32_t coordBits)
-{
-  return PointDToPointU(pt.x, pt.y, coordBits);
-}
-
-m2::PointD PointUToPointD(m2::PointU const & pt, uint32_t coordBits)
-{
-  return m2::PointD(static_cast<double>(pt.x) * (MercatorBounds::maxX - MercatorBounds::minX) /
-                            CoordSize(coordBits) +
-                        MercatorBounds::minX,
-                    static_cast<double>(pt.y) * (MercatorBounds::maxY - MercatorBounds::minY) /
-                            CoordSize(coordBits) +
-                        MercatorBounds::minY);
-}
diff --git a/coding/pointd_to_pointu.hpp b/coding/pointd_to_pointu.hpp
deleted file mode 100644
index e5fd99a042..0000000000
--- a/coding/pointd_to_pointu.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include "geometry/point2d.hpp"
-
-#include <cstdint>
-
-#define POINT_COORD_BITS 30
-
-uint32_t DoubleToUint32(double x, double min, double max, uint32_t coordBits);
-
-double Uint32ToDouble(uint32_t x, double min, double max, uint32_t coordBits);
-
-m2::PointU PointDToPointU(double x, double y, uint32_t coordBits);
-
-m2::PointU PointDToPointU(m2::PointD const & pt, uint32_t coordBits);
-
-m2::PointD PointUToPointD(m2::PointU const & p, uint32_t coordBits);
diff --git a/coding/traffic.hpp b/coding/traffic.hpp
index 97b6d317fb..363cc56e2f 100644
--- a/coding/traffic.hpp
+++ b/coding/traffic.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/reader.hpp"
 #include "coding/varint.hpp"
 #include "coding/writer.hpp"
diff --git a/defines.hpp b/defines.hpp
index 6642fc7f54..9c2bcb0172 100644
--- a/defines.hpp
+++ b/defines.hpp
@@ -116,4 +116,3 @@
 #define BOOKING_EXCLUDED_FILE "booking_excluded.txt"
 
 auto constexpr kInvalidRatingValue = 0.0f;
-auto constexpr kMwmPointAccuracy = 1e-5;
diff --git a/drape_frontend/tile_key.cpp b/drape_frontend/tile_key.cpp
index b737d14975..86894efd85 100755
--- a/drape_frontend/tile_key.cpp
+++ b/drape_frontend/tile_key.cpp
@@ -81,14 +81,14 @@ m2::RectD TileKey::GetGlobalRect(bool clipByDataMaxZoom) const
 {
   int const zoomLevel = clipByDataMaxZoom ? ClipTileZoomByMaxDataZoom(m_zoomLevel) : m_zoomLevel;
   ASSERT_GREATER(zoomLevel, 0, ());
-  double const worldSizeDevisor = 1 << (zoomLevel - 1);
+  double const worldSizeDivisor = 1 << (zoomLevel - 1);
   // Mercator SizeX and SizeY are equal.
-  double const rectSize = (MercatorBounds::maxX - MercatorBounds::minX) / worldSizeDevisor;
+  double const rectSize = MercatorBounds::kRangeX / worldSizeDivisor;
 
   double const startX = m_x * rectSize;
   double const startY = m_y * rectSize;
 
-  return m2::RectD (startX, startY, startX + rectSize, startY + rectSize);
+  return m2::RectD(startX, startY, startX + rectSize, startY + rectSize);
 }
 
 m2::PointI TileKey::GetTileCoords() const
diff --git a/drape_frontend/tile_utils.cpp b/drape_frontend/tile_utils.cpp
index e8bdcaf2db..75809c5de2 100755
--- a/drape_frontend/tile_utils.cpp
+++ b/drape_frontend/tile_utils.cpp
@@ -13,8 +13,7 @@ CoverageResult CalcTilesCoverage(m2::RectD const & rect, int targetZoom,
                                  std::function<void(int, int)> const & processTile)
 {
   ASSERT_GREATER(targetZoom, 0, ());
-  double const range = MercatorBounds::maxX - MercatorBounds::minX;
-  double const rectSize = range / (1 << (targetZoom - 1));
+  double const rectSize = MercatorBounds::kRangeX / (1 << (targetZoom - 1));
 
   CoverageResult result;
   result.m_minTileX = static_cast<int>(floor(rect.minX() / rectSize));
@@ -48,8 +47,7 @@ int ClipTileZoomByMaxDataZoom(int zoom)
 TileKey GetTileKeyByPoint(m2::PointD const & pt, int zoom)
 {
   ASSERT_GREATER(zoom, 0, ());
-  double const range = MercatorBounds::maxX - MercatorBounds::minX;
-  double const rectSize = range / (1 << (zoom - 1));
+  double const rectSize = MercatorBounds::kRangeX / (1 << (zoom - 1));
   return TileKey(static_cast<int>(floor(pt.x / rectSize)),
                  static_cast<int>(floor(pt.y / rectSize)), zoom);
 }
diff --git a/drape_frontend/user_mark_generator.cpp b/drape_frontend/user_mark_generator.cpp
index 5c7ed8475e..25e87fc168 100644
--- a/drape_frontend/user_mark_generator.cpp
+++ b/drape_frontend/user_mark_generator.cpp
@@ -113,9 +113,8 @@ void UserMarkGenerator::UpdateIndex(kml::MarkGroupId groupId)
     {
       if (zoomLevel < startZoom)
         continue;
-      // Process spline by segments that no longer than tile size.
-      double const range = MercatorBounds::maxX - MercatorBounds::minX;
-      double const maxLength = range / (1 << (zoomLevel - 1));
+      // Process spline by segments that are no longer than tile size.
+      double const maxLength = MercatorBounds::kRangeX / (1 << (zoomLevel - 1));
 
       df::ProcessSplineSegmentRects(params.m_spline, maxLength,
                                     [&](m2::RectD const & segmentRect)
diff --git a/drape_frontend/user_mark_shapes.cpp b/drape_frontend/user_mark_shapes.cpp
index 8f2b29e4a1..8340553094 100644
--- a/drape_frontend/user_mark_shapes.cpp
+++ b/drape_frontend/user_mark_shapes.cpp
@@ -534,8 +534,7 @@ void CacheUserLines(ref_ptr<dp::GraphicsContext> context, TileKey const & tileKe
 
     m2::RectD const tileRect = tileKey.GetGlobalRect();
 
-    double const range = MercatorBounds::maxX - MercatorBounds::minX;
-    double const maxLength = range / (1 << (tileKey.m_zoomLevel - 1));
+    double const maxLength = MercatorBounds::kRangeX / (1 << (tileKey.m_zoomLevel - 1));
 
     bool intersected = false;
     ProcessSplineSegmentRects(renderInfo.m_spline, maxLength,
diff --git a/drape_frontend/visual_params.cpp b/drape_frontend/visual_params.cpp
index 8ed7513a49..ddc8ce66ca 100644
--- a/drape_frontend/visual_params.cpp
+++ b/drape_frontend/visual_params.cpp
@@ -197,7 +197,7 @@ int GetTileScaleBase(ScreenBase const & s)
 int GetTileScaleBase(m2::RectD const & r)
 {
   double const sz = std::max(r.SizeX(), r.SizeY());
-  return std::max(1, base::rounds(log((MercatorBounds::maxX - MercatorBounds::minX) / sz) / log(2.0)));
+  return std::max(1, base::rounds(log(MercatorBounds::kRangeX / sz) / log(2.0)));
 }
 
 double GetTileScaleBase(double drawScale)
@@ -221,7 +221,7 @@ m2::RectD GetRectForDrawScale(int drawScale, m2::PointD const & center, uint32_t
   // +1 - we will calculate half length for each side
   double const factor = 1 << (std::max(1, drawScale - GetTileScaleIncrement(tileSize, visualScale)) + 1);
 
-  double const len = (MercatorBounds::maxX - MercatorBounds::minX) / factor;
+  double const len = MercatorBounds::kRangeX / factor;
 
   return m2::RectD(MercatorBounds::ClampX(center.x - len),
                    MercatorBounds::ClampY(center.y - len),
@@ -350,7 +350,7 @@ double GetScreenScale(double zoomLevel)
 {
   VisualParams const & p = VisualParams::Instance();
   auto const factor = pow(2.0, GetTileScaleBase(zoomLevel));
-  auto const len = (MercatorBounds::maxX - MercatorBounds::minX) / factor;
+  auto const len = MercatorBounds::kRangeX / factor;
   auto const pxLen = static_cast<double>(p.GetTileSize());
   return len / pxLen;
 }
@@ -360,7 +360,7 @@ double GetZoomLevel(double screenScale)
   VisualParams const & p = VisualParams::Instance();
   auto const pxLen = static_cast<double>(p.GetTileSize());
   auto const len = pxLen * screenScale;
-  auto const factor = (MercatorBounds::maxX - MercatorBounds::minX) / len;
+  auto const factor = MercatorBounds::kRangeX / len;
   static double const kLog2 = log(2.0);
   return base::clamp(GetDrawTileScale(fabs(log(factor) / kLog2)), 1.0, scales::GetUpperStyleScale() + 1.0);
 }
diff --git a/generator/camera_info_collector.cpp b/generator/camera_info_collector.cpp
index 5166b9822b..85f61f79d4 100644
--- a/generator/camera_info_collector.cpp
+++ b/generator/camera_info_collector.cpp
@@ -6,7 +6,7 @@
 
 #include "geometry/mercator.hpp"
 
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/reader.hpp"
 #include "coding/varint.hpp"
 
diff --git a/generator/coastlines_generator.cpp b/generator/coastlines_generator.cpp
index f2f81fb3ea..38c3618ed7 100644
--- a/generator/coastlines_generator.cpp
+++ b/generator/coastlines_generator.cpp
@@ -2,7 +2,7 @@
 
 #include "generator/feature_builder.hpp"
 
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 
 #include "geometry/region2d/binary_operators.hpp"
 
diff --git a/generator/feature_builder.cpp b/generator/feature_builder.cpp
index cc8ebafe01..8b911b7cee 100644
--- a/generator/feature_builder.cpp
+++ b/generator/feature_builder.cpp
@@ -192,12 +192,12 @@ namespace
 {
 bool IsEqual(double d1, double d2)
 {
-  return base::AlmostEqualAbs(d1, d2, MercatorBounds::GetCellID2PointAbsEpsilon());
+  return base::AlmostEqualAbs(d1, d2, kCellIdToPointEps);
 }
 
 bool IsEqual(m2::PointD const & p1, m2::PointD const & p2)
 {
-  return p1.EqualDxDy(p2, MercatorBounds::GetCellID2PointAbsEpsilon());
+  return p1.EqualDxDy(p2, kCellIdToPointEps);
 }
 
 bool IsEqual(m2::RectD const & r1, m2::RectD const & r2)
diff --git a/generator/feature_helpers.cpp b/generator/feature_helpers.cpp
index e8299ea5c8..6fdf57455b 100644
--- a/generator/feature_helpers.cpp
+++ b/generator/feature_helpers.cpp
@@ -4,7 +4,7 @@
 
 #include "indexer/feature_visibility.hpp"
 
-#include "coding/point_to_integer.hpp"
+#include "coding/point_coding.hpp"
 
 #include "base/stl_helpers.hpp"
 
diff --git a/generator/feature_merger.cpp b/generator/feature_merger.cpp
index 2855af89d2..d14e8362aa 100644
--- a/generator/feature_merger.cpp
+++ b/generator/feature_merger.cpp
@@ -4,7 +4,7 @@
 #include "indexer/feature_algo.hpp"
 #include "indexer/feature_visibility.hpp"
 
-#include "coding/point_to_integer.hpp"
+#include "coding/point_coding.hpp"
 
 MergedFeatureBuilder1::MergedFeatureBuilder1(FeatureBuilder1 const & fb)
   : FeatureBuilder1(fb), m_isRound(false)
diff --git a/generator/generator_tests/coasts_test.cpp b/generator/generator_tests/coasts_test.cpp
index 7ddc9eb705..61761d9262 100644
--- a/generator/generator_tests/coasts_test.cpp
+++ b/generator/generator_tests/coasts_test.cpp
@@ -4,7 +4,7 @@
 #include "generator/feature_generator.hpp"
 #include "generator/feature_helpers.hpp"
 
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 
 #include "geometry/cellid.hpp"
 #include "geometry/mercator.hpp"
diff --git a/generator/generator_tests/feature_merger_test.cpp b/generator/generator_tests/feature_merger_test.cpp
index 47d72b70fb..986ad5c858 100644
--- a/generator/generator_tests/feature_merger_test.cpp
+++ b/generator/generator_tests/feature_merger_test.cpp
@@ -4,7 +4,7 @@
 
 #include "indexer/classificator_loader.hpp"
 
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 
 namespace
 {
diff --git a/generator/generator_tests/triangles_tree_coding_test.cpp b/generator/generator_tests/triangles_tree_coding_test.cpp
index 9074bbc97f..dbb3346758 100644
--- a/generator/generator_tests/triangles_tree_coding_test.cpp
+++ b/generator/generator_tests/triangles_tree_coding_test.cpp
@@ -3,7 +3,7 @@
 #include "generator/tesselator.hpp"
 
 #include "coding/geometry_coding.hpp"
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/reader.hpp"
 #include "coding/writer.hpp"
 
@@ -15,7 +15,7 @@ namespace
 
   bool is_equal(P const & p1, P const & p2)
   {
-    return p1.EqualDxDy(p2, MercatorBounds::GetCellID2PointAbsEpsilon());
+    return p1.EqualDxDy(p2, kCellIdToPointEps);
   }
 
   bool FindTriangle(serial::OutPointsT const & test, P arr[])
diff --git a/generator/routing_index_generator.cpp b/generator/routing_index_generator.cpp
index ab4354036b..b809c7464a 100644
--- a/generator/routing_index_generator.cpp
+++ b/generator/routing_index_generator.cpp
@@ -27,8 +27,7 @@
 #include "coding/file_container.hpp"
 #include "coding/file_name_utils.hpp"
 #include "coding/geometry_coding.hpp"
-#include "coding/point_to_integer.hpp"
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/reader.hpp"
 
 #include "geometry/point2d.hpp"
diff --git a/generator/world_map_generator.hpp b/generator/world_map_generator.hpp
index 7d3028474d..00e2c5cb34 100644
--- a/generator/world_map_generator.hpp
+++ b/generator/world_map_generator.hpp
@@ -9,7 +9,7 @@
 #include "indexer/classificator.hpp"
 #include "indexer/scales.hpp"
 
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 
 #include "geometry/polygon.hpp"
 #include "geometry/region2d.hpp"
diff --git a/geometry/geometry_tests/mercator_test.cpp b/geometry/geometry_tests/mercator_test.cpp
index d867ac2e89..6236b25019 100644
--- a/geometry/geometry_tests/mercator_test.cpp
+++ b/geometry/geometry_tests/mercator_test.cpp
@@ -39,8 +39,8 @@ UNIT_TEST(Mercator_DirectInferseF)
   double y = MercatorBounds::LatToY(lat);
   double lat1 = MercatorBounds::YToLat(y);
   TEST_LESS(fabs(lat - lat1), eps, ("Too big round error"));
-  TEST_LESS(fabs(MercatorBounds::maxX - MercatorBounds::maxY), eps, ("Non-square maxX and maxY"));
-  TEST_LESS(fabs(MercatorBounds::minX - MercatorBounds::minY), eps, ("Non-square minX and minY"));
+  TEST_LESS(fabs(MercatorBounds::kMaxX - MercatorBounds::kMaxY), eps, ("Non-square maxX and maxY"));
+  TEST_LESS(fabs(MercatorBounds::kMinX - MercatorBounds::kMinY), eps, ("Non-square minX and minY"));
 }
 
 UNIT_TEST(Mercator_ErrorToRadius)
diff --git a/geometry/mercator.cpp b/geometry/mercator.cpp
index 0977316e1c..b997aace27 100644
--- a/geometry/mercator.cpp
+++ b/geometry/mercator.cpp
@@ -7,11 +7,6 @@
 
 using namespace std;
 
-double MercatorBounds::minX = -180;
-double MercatorBounds::maxX = 180;
-double MercatorBounds::minY = -180;
-double MercatorBounds::maxY = 180;
-
 m2::RectD MercatorBounds::MetresToXY(double lon, double lat, double lonMetresR, double latMetresR)
 {
   double const latDegreeOffset = latMetresR * degreeInMetres;
diff --git a/geometry/mercator.hpp b/geometry/mercator.hpp
index 7c61f7394e..d3e8270e2c 100644
--- a/geometry/mercator.hpp
+++ b/geometry/mercator.hpp
@@ -8,21 +8,23 @@
 
 struct MercatorBounds
 {
-  static double minX;
-  static double maxX;
-  static double minY;
-  static double maxY;
+  static double constexpr kMinX = -180.0;
+  static double constexpr kMaxX = 180.0;
+  static double constexpr kMinY = -180.0;
+  static double constexpr kMaxY = 180.0;
+  static double constexpr kRangeX = kMaxX - kMinX;
+  static double constexpr kRangeY = kMaxY - kMinY;
 
-  static m2::RectD FullRect() { return m2::RectD(minX, minY, maxX, maxY); }
+  static m2::RectD FullRect() { return m2::RectD(kMinX, kMinY, kMaxX, kMaxY); }
 
   static bool ValidLon(double d) { return base::between_s(-180.0, 180.0, d); }
   static bool ValidLat(double d) { return base::between_s(-90.0, 90.0, d); }
 
-  static bool ValidX(double d) { return base::between_s(minX, maxX, d); }
-  static bool ValidY(double d) { return base::between_s(minY, maxY, d); }
+  static bool ValidX(double d) { return base::between_s(kMinX, kMaxX, d); }
+  static bool ValidY(double d) { return base::between_s(kMinY, kMaxY, d); }
 
-  static double ClampX(double d) { return base::clamp(d, minX, maxX); }
-  static double ClampY(double d) { return base::clamp(d, minY, maxY); }
+  static double ClampX(double d) { return base::clamp(d, kMinX, kMaxX); }
+  static double ClampY(double d) { return base::clamp(d, kMinY, kMaxY); }
 
   static double YToLat(double y) { return base::RadToDeg(2.0 * atan(tanh(0.5 * base::DegToRad(y)))); }
 
@@ -72,8 +74,6 @@ struct MercatorBounds
 
   static m2::PointD GetSmPoint(m2::PointD const & pt, double lonMetresR, double latMetresR);
 
-  static double constexpr GetCellID2PointAbsEpsilon() { return 1.0E-4; }
-
   static m2::PointD FromLatLon(double lat, double lon)
   {
     return m2::PointD(LonToX(lon), LatToY(lat));
diff --git a/indexer/cell_id.hpp b/indexer/cell_id.hpp
index d8a931a9a5..166b485470 100644
--- a/indexer/cell_id.hpp
+++ b/indexer/cell_id.hpp
@@ -23,20 +23,20 @@ class CellIdConverter
 public:
   static double XToCellIdX(double x)
   {
-    return (x - Bounds::minX) / StepX();
+    return (x - Bounds::kMinX) / StepX();
   }
   static double YToCellIdY(double y)
   {
-    return (y - Bounds::minY) / StepY();
+    return (y - Bounds::kMinY) / StepY();
   }
 
   static double CellIdXToX(double  x)
   {
-    return (x*StepX() + Bounds::minX);
+    return (x*StepX() + Bounds::kMinX);
   }
   static double CellIdYToY(double y)
   {
-    return (y*StepY() + Bounds::minY);
+    return (y*StepY() + Bounds::kMinY);
   }
 
   static CellId ToCellId(double x, double y)
@@ -87,19 +87,20 @@ public:
   {
     std::pair<uint32_t, uint32_t> const xy = id.XY();
     uint32_t const r = id.Radius();
-    minX = (xy.first - r) * StepX() + Bounds::minX;
-    maxX = (xy.first + r) * StepX() + Bounds::minX;
-    minY = (xy.second - r) * StepY() + Bounds::minY;
-    maxY = (xy.second + r) * StepY() + Bounds::minY;
+    minX = (xy.first - r) * StepX() + Bounds::kMinX;
+    maxX = (xy.first + r) * StepX() + Bounds::kMinX;
+    minY = (xy.second - r) * StepY() + Bounds::kMinY;
+    maxY = (xy.second + r) * StepY() + Bounds::kMinY;
   }
 
 private:
   inline static double StepX()
   {
-    return double(Bounds::maxX - Bounds::minX) / CellId::MAX_COORD;
+    return static_cast<double>(Bounds::kRangeX) / CellId::MAX_COORD;
   }
+
   inline static double StepY()
   {
-    return double(Bounds::maxY - Bounds::minY) / CellId::MAX_COORD;
+    return static_cast<double>(Bounds::kRangeY) / CellId::MAX_COORD;
   }
 };
diff --git a/indexer/centers_table.cpp b/indexer/centers_table.cpp
index 57152a4c8d..5098ec2232 100644
--- a/indexer/centers_table.cpp
+++ b/indexer/centers_table.cpp
@@ -6,7 +6,7 @@
 #include "coding/file_container.hpp"
 #include "coding/geometry_coding.hpp"
 #include "coding/memory_region.hpp"
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/reader.hpp"
 #include "coding/succinct_mapper.hpp"
 #include "coding/varint.hpp"
diff --git a/indexer/cities_boundaries_serdes.hpp b/indexer/cities_boundaries_serdes.hpp
index 406683f94b..e3872932b5 100644
--- a/indexer/cities_boundaries_serdes.hpp
+++ b/indexer/cities_boundaries_serdes.hpp
@@ -5,7 +5,7 @@
 #include "coding/bit_streams.hpp"
 #include "coding/elias_coder.hpp"
 #include "coding/geometry_coding.hpp"
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/reader.hpp"
 #include "coding/varint.hpp"
 #include "coding/write_to_sink.hpp"
@@ -390,7 +390,7 @@ struct CitiesBoundariesSerDes
     visitor(header);
 
     serial::GeometryCodingParams const params(
-        header.m_coordBits, m2::PointD(MercatorBounds::minX, MercatorBounds::minY));
+        header.m_coordBits, m2::PointD(MercatorBounds::kMinX, MercatorBounds::kMinY));
     CitiesBoundariesEncoder<Sink> encoder(sink, params);
     encoder(boundaries);
   }
@@ -409,12 +409,12 @@ struct CitiesBoundariesSerDes
     HeaderV0 header;
     visitor(header);
 
-    auto const wx = MercatorBounds::maxX - MercatorBounds::minX;
-    auto const wy = MercatorBounds::maxY - MercatorBounds::minY;
+    auto const wx = MercatorBounds::kRangeX;
+    auto const wy = MercatorBounds::kRangeY;
     precision = std::max(wx, wy) / pow(2, header.m_coordBits);
 
     serial::GeometryCodingParams const params(
-        header.m_coordBits, m2::PointD(MercatorBounds::minX, MercatorBounds::minY));
+        header.m_coordBits, m2::PointD(MercatorBounds::kMinX, MercatorBounds::kMinY));
     CitiesBoundariesDecoderV0<Source> decoder(source, params);
     decoder(boundaries);
   }
diff --git a/indexer/data_header.cpp b/indexer/data_header.cpp
index 0f4b2a3317..17b393c3fa 100644
--- a/indexer/data_header.cpp
+++ b/indexer/data_header.cpp
@@ -5,8 +5,7 @@
 
 #include "coding/file_container.hpp"
 #include "coding/file_writer.hpp"
-#include "coding/point_to_integer.hpp"
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/varint.hpp"
 #include "coding/write_to_sink.hpp"
 
diff --git a/indexer/data_source_helpers.cpp b/indexer/data_source_helpers.cpp
index ffd6418512..65945e41d3 100644
--- a/indexer/data_source_helpers.cpp
+++ b/indexer/data_source_helpers.cpp
@@ -33,8 +33,7 @@ void ForEachFeatureAtPoint(DataSource const & dataSource, function<void(FeatureT
       auto limitRect = ft.GetLimitRect(kScale);
       // Be a little more tolerant. When used by editor mercator is given
       // with some error, so we must extend limit rect a bit.
-      limitRect.Inflate(MercatorBounds::GetCellID2PointAbsEpsilon(),
-                        MercatorBounds::GetCellID2PointAbsEpsilon());
+      limitRect.Inflate(kCellIdToPointEps, kCellIdToPointEps);
       if (limitRect.IsPointInside(mercator) &&
           feature::GetMinDistanceMeters(ft, mercator) <= toleranceInMeters)
       {
diff --git a/indexer/feature_covering.hpp b/indexer/feature_covering.hpp
index 7524435d70..81336567fc 100644
--- a/indexer/feature_covering.hpp
+++ b/indexer/feature_covering.hpp
@@ -4,6 +4,8 @@
 #include "indexer/cell_id.hpp"
 #include "indexer/scales.hpp"
 
+#include "coding/point_coding.hpp"
+
 #include "geometry/cellid.hpp"
 #include "geometry/mercator.hpp"
 #include "geometry/rect2d.hpp"
@@ -41,7 +43,7 @@ void SortAndMergeIntervals(Intervals v, Intervals & res);
 template <int DEPTH_LEVELS>
 m2::CellId<DEPTH_LEVELS> GetRectIdAsIs(m2::RectD const & r)
 {
-  double const eps = MercatorBounds::GetCellID2PointAbsEpsilon();
+  double const eps = kCellIdToPointEps;
   using Converter = CellIdConverter<MercatorBounds, m2::CellId<DEPTH_LEVELS>>;
 
   return Converter::Cover2PointsWithCell(
diff --git a/indexer/indexer_tests/bounds.hpp b/indexer/indexer_tests/bounds.hpp
index ae6e8a4df8..811c07061c 100644
--- a/indexer/indexer_tests/bounds.hpp
+++ b/indexer/indexer_tests/bounds.hpp
@@ -5,10 +5,12 @@ struct Bounds
 {
   enum
   {
-    minX = MinX,
-    maxX = MaxX,
-    minY = MinY,
-    maxY = MaxY
+    kMinX = MinX,
+    kMaxX = MaxX,
+    kMinY = MinY,
+    kMaxY = MaxY,
+    kRangeX = kMaxX - kMinX,
+    kRangeY = kMaxY - kMinY,
   };
 
   static m2::RectD FullRect() { return {MinX, MinY, MaxX, MaxY}; }
diff --git a/indexer/scales.cpp b/indexer/scales.cpp
index 9555e8fb9d..6dcc12b9a7 100644
--- a/indexer/scales.cpp
+++ b/indexer/scales.cpp
@@ -25,8 +25,8 @@ namespace scales
   double GetScaleLevelD(m2::RectD const & r)
   {
     // TODO: fix scale factors for mercator projection
-    double const dx = (MercatorBounds::maxX - MercatorBounds::minX) / r.SizeX();
-    double const dy = (MercatorBounds::maxY - MercatorBounds::minY) / r.SizeY();
+    double const dx = MercatorBounds::kRangeX / r.SizeX();
+    double const dy = MercatorBounds::kRangeY / r.SizeY();
 
     // get the average ratio
     return GetScaleLevelD((dx + dy) / 2.0);
@@ -56,10 +56,10 @@ namespace scales
     ASSERT_GREATER ( dy, 0.0, () );
     ASSERT_GREATER ( dx, 0.0, () );
 
-    double const xL = (MercatorBounds::maxX - MercatorBounds::minX) / (2.0 * dx);
-    double const yL = (MercatorBounds::maxY - MercatorBounds::minY) / (2.0 * dy);
-    ASSERT_GREATER ( xL, 0.0, () );
-    ASSERT_GREATER ( yL, 0.0, () );
+    double const xL = MercatorBounds::kRangeX / (2.0 * dx);
+    double const yL = MercatorBounds::kRangeY / (2.0 * dy);
+    ASSERT_GREATER(xL, 0.0, ());
+    ASSERT_GREATER(yL, 0.0, ());
 
     return m2::RectD(MercatorBounds::ClampX(center.x - xL),
                      MercatorBounds::ClampY(center.y - yL),
@@ -71,7 +71,7 @@ namespace scales
   {
     double GetEpsilonImpl(long level, double pixelTolerance)
     {
-      return (MercatorBounds::maxX - MercatorBounds::minX) * pixelTolerance / double(256L << level);
+      return MercatorBounds::kRangeX * pixelTolerance / double(256L << level);
     }
   }
 
diff --git a/kml/visitors.hpp b/kml/visitors.hpp
index 9c40b29ba1..4670a57fd7 100644
--- a/kml/visitors.hpp
+++ b/kml/visitors.hpp
@@ -3,8 +3,7 @@
 #include "kml/types.hpp"
 
 #include "coding/geometry_coding.hpp"
-#include "coding/point_to_integer.hpp"
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/text_storage.hpp"
 #include "coding/varint.hpp"
 
diff --git a/local_ads/statistics.cpp b/local_ads/statistics.cpp
index b631d06832..0c7bc82e0c 100644
--- a/local_ads/statistics.cpp
+++ b/local_ads/statistics.cpp
@@ -8,8 +8,7 @@
 
 #include "coding/file_name_utils.hpp"
 #include "coding/file_writer.hpp"
-#include "coding/point_to_integer.hpp"
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/sha1.hpp"
 #include "coding/url_encode.hpp"
 #include "coding/write_to_sink.hpp"
diff --git a/map/framework.cpp b/map/framework.cpp
index bac43df5fb..1279d60c9b 100644
--- a/map/framework.cpp
+++ b/map/framework.cpp
@@ -74,6 +74,7 @@
 #include "coding/endianness.hpp"
 #include "coding/file_name_utils.hpp"
 #include "coding/multilang_utf8_string.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/transliteration.hpp"
 #include "coding/url_encode.hpp"
 #include "coding/zip_reader.hpp"
diff --git a/map/local_ads_manager.cpp b/map/local_ads_manager.cpp
index 940eb00d0e..c999a4b66d 100644
--- a/map/local_ads_manager.cpp
+++ b/map/local_ads_manager.cpp
@@ -22,7 +22,7 @@
 
 #include "coding/file_name_utils.hpp"
 #include "coding/multilang_utf8_string.hpp"
-#include "coding/point_to_integer.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/url_encode.hpp"
 
 #include "base/url_helpers.hpp"
diff --git a/metrics/eye_info.hpp b/metrics/eye_info.hpp
index 240e31f1d6..55972aaf12 100644
--- a/metrics/eye_info.hpp
+++ b/metrics/eye_info.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "coding/point_coding.hpp"
+
 #include "geometry/mercator.hpp"
 #include "geometry/point2d.hpp"
 #include "geometry/tree4d.hpp"
@@ -14,8 +16,6 @@
 #include <type_traits>
 #include <vector>
 
-#include "defines.hpp"
-
 namespace eye
 {
 namespace traits
diff --git a/routing/speed_camera_ser_des.cpp b/routing/speed_camera_ser_des.cpp
index e9aff6bbf7..e8a2d3f678 100644
--- a/routing/speed_camera_ser_des.cpp
+++ b/routing/speed_camera_ser_des.cpp
@@ -1,6 +1,6 @@
 #include "routing/speed_camera_ser_des.hpp"
 
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/varint.hpp"
 
 #include "base/assert.hpp"
diff --git a/routing/speed_camera_ser_des.hpp b/routing/speed_camera_ser_des.hpp
index 1e20c3c74e..f13eb46e78 100644
--- a/routing/speed_camera_ser_des.hpp
+++ b/routing/speed_camera_ser_des.hpp
@@ -7,7 +7,7 @@
 
 #include "coding/file_container.hpp"
 #include "coding/file_writer.hpp"
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/reader.hpp"
 #include "coding/varint.hpp"
 #include "coding/write_to_sink.hpp"
diff --git a/search/geometry_cache.cpp b/search/geometry_cache.cpp
index f98dd1e401..5970db54b7 100644
--- a/search/geometry_cache.cpp
+++ b/search/geometry_cache.cpp
@@ -10,7 +10,7 @@ namespace search
 {
 namespace
 {
-double constexpr kCellEps = MercatorBounds::GetCellID2PointAbsEpsilon();
+double constexpr kCellEps = kCellIdToPointEps;
 }  // namespace
 
 // GeometryCache -----------------------------------------------------------------------------------
diff --git a/search/search_trie.hpp b/search/search_trie.hpp
index 18d195f0da..ed180e8292 100644
--- a/search/search_trie.hpp
+++ b/search/search_trie.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "coding/geometry_coding.hpp"
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 
 namespace search
 {
diff --git a/storage/country_polygon.hpp b/storage/country_polygon.hpp
index 57f1f896a0..992a887258 100644
--- a/storage/country_polygon.hpp
+++ b/storage/country_polygon.hpp
@@ -3,7 +3,7 @@
 #include "storage/country_decl.hpp"
 
 #include "coding/geometry_coding.hpp"
-#include "coding/point_to_integer.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/read_write_utils.hpp"
 #include "coding/varint.hpp"
 
diff --git a/storage/storage_integration_tests/lightweight_matching_tests.cpp b/storage/storage_integration_tests/lightweight_matching_tests.cpp
index 561ee10f8f..389b171602 100644
--- a/storage/storage_integration_tests/lightweight_matching_tests.cpp
+++ b/storage/storage_integration_tests/lightweight_matching_tests.cpp
@@ -33,9 +33,9 @@ UNIT_CLASS_TEST(CountryInfoReader, LightweightMatching)
 
   LOG(LINFO, ("Generating dataset..."));
   std::vector<PointAndCountry> dataset;
-  for (auto x = MercatorBounds::minX; x <= MercatorBounds::maxX; x += kStepInMercator)
+  for (auto x = MercatorBounds::kMinX; x <= MercatorBounds::kMaxX; x += kStepInMercator)
   {
-    for (auto y = MercatorBounds::minY; y <= MercatorBounds::maxY; y += kStepInMercator)
+    for (auto y = MercatorBounds::kMinY; y <= MercatorBounds::kMaxY; y += kStepInMercator)
     {
       m2::PointD pt(x, y);
       dataset.emplace_back(std::move(pt), reader->GetRegionCountryId(pt));
diff --git a/transit/transit_serdes.hpp b/transit/transit_serdes.hpp
index 6f6a88bc57..2f53098bff 100644
--- a/transit/transit_serdes.hpp
+++ b/transit/transit_serdes.hpp
@@ -5,8 +5,7 @@
 #include "geometry/point2d.hpp"
 
 #include "coding/geometry_coding.hpp"
-#include "coding/point_to_integer.hpp"
-#include "coding/pointd_to_pointu.hpp"
+#include "coding/point_coding.hpp"
 #include "coding/read_write_utils.hpp"
 #include "coding/reader.hpp"
 #include "coding/varint.hpp"
diff --git a/ugc/storage.cpp b/ugc/storage.cpp
index 95febbe8bf..d6eedaf446 100644
--- a/ugc/storage.cpp
+++ b/ugc/storage.cpp
@@ -17,6 +17,7 @@
 #include "coding/file_reader.hpp"
 #include "coding/file_writer.hpp"
 #include "coding/internal/file_data.hpp"
+#include "coding/point_coding.hpp"
 
 #include "base/stl_helpers.hpp"
 
@@ -29,8 +30,6 @@
 
 #include <boost/optional/optional.hpp>
 
-#include "defines.hpp"
-
 using namespace std;
 
 namespace
diff --git a/xcode/coding/coding.xcodeproj/project.pbxproj b/xcode/coding/coding.xcodeproj/project.pbxproj
index 3b4fa00635..cbf34f843e 100644
--- a/xcode/coding/coding.xcodeproj/project.pbxproj
+++ b/xcode/coding/coding.xcodeproj/project.pbxproj
@@ -22,16 +22,16 @@
 		3949172C1BAC3CAC002A8C4F /* libminizip.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 394917281BAC3CAC002A8C4F /* libminizip.a */; };
 		3949172D1BAC3CAC002A8C4F /* libsuccinct.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 394917291BAC3CAC002A8C4F /* libsuccinct.a */; };
 		394917301BAC3CC9002A8C4F /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 3949172F1BAC3CC9002A8C4F /* libz.tbd */; };
-		395D1A89207BBA16001164A5 /* pointd_to_pointu.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 395D1A87207BBA16001164A5 /* pointd_to_pointu.cpp */; };
-		395D1A8A207BBA16001164A5 /* pointd_to_pointu.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 395D1A88207BBA16001164A5 /* pointd_to_pointu.hpp */; };
 		395D1A95207BBF63001164A5 /* zlib_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 395D1A91207BBBAC001164A5 /* zlib_test.cpp */; };
-		395D1A96207BBF63001164A5 /* pointd_to_pointu_tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 395D1A8F207BBBA5001164A5 /* pointd_to_pointu_tests.cpp */; };
 		395D1A97207BBF63001164A5 /* text_storage_tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 395D1A8D207BBB9E001164A5 /* text_storage_tests.cpp */; };
 		395D1A98207BBF63001164A5 /* bwt_coder_tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 395D1A8B207BBB95001164A5 /* bwt_coder_tests.cpp */; };
 		39B2B97B1FB4692D00AB85A1 /* text_storage.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 39B2B97A1FB4692D00AB85A1 /* text_storage.hpp */; };
 		39B2B97D1FB4693500AB85A1 /* bwt_coder.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 39B2B97C1FB4693400AB85A1 /* bwt_coder.hpp */; };
 		39B2B97F1FB4693B00AB85A1 /* elias_coder.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 39B2B97E1FB4693B00AB85A1 /* elias_coder.hpp */; };
 		39B2B9811FB4694300AB85A1 /* memory_region.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 39B2B9801FB4694300AB85A1 /* memory_region.hpp */; };
+		39C3C0BC21A43061003B4712 /* point_coding.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 39C3C0BA21A43060003B4712 /* point_coding.hpp */; };
+		39C3C0BD21A43061003B4712 /* point_coding.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39C3C0BB21A43061003B4712 /* point_coding.cpp */; };
+		39C3C0C221A43200003B4712 /* point_coding_tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39C3C0BE21A431BF003B4712 /* point_coding_tests.cpp */; };
 		39F376C6207D327B0058E8E0 /* geometry_coding.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39F376C4207D327B0058E8E0 /* geometry_coding.cpp */; };
 		39F376C7207D327B0058E8E0 /* geometry_coding.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 39F376C5207D327B0058E8E0 /* geometry_coding.hpp */; };
 		39F376C9207D32820058E8E0 /* tesselator_decl.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 39F376C8207D32820058E8E0 /* tesselator_decl.hpp */; };
@@ -48,9 +48,6 @@
 		4563B061205909290057556D /* serdes_binary_header.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 4563B05E205909280057556D /* serdes_binary_header.hpp */; };
 		4563B062205909290057556D /* sha1.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4563B05F205909280057556D /* sha1.cpp */; };
 		4563B063205909290057556D /* sha1.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 4563B060205909280057556D /* sha1.hpp */; };
-		45C108B41E9CFE69000FE1F6 /* point_to_integer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 45C108B21E9CFE69000FE1F6 /* point_to_integer.cpp */; };
-		45C108B51E9CFE69000FE1F6 /* point_to_integer.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 45C108B31E9CFE69000FE1F6 /* point_to_integer.hpp */; };
-		45C108B81E9CFE7B000FE1F6 /* point_to_integer_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 45C108B61E9CFE78000FE1F6 /* point_to_integer_test.cpp */; };
 		45C108BA1E9CFF8E000FE1F6 /* libgeometry.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 45C108B91E9CFF8E000FE1F6 /* libgeometry.a */; };
 		670BAACB1D0B0C1E000302DA /* huffman.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 394917221BAC3C2F002A8C4F /* huffman.cpp */; };
 		670D04BD1B0BA92D0013A7AC /* expat_impl.h in Headers */ = {isa = PBXBuildFile; fileRef = 670D04B31B0BA9050013A7AC /* expat_impl.h */; };
@@ -188,16 +185,16 @@
 		394917281BAC3CAC002A8C4F /* libminizip.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libminizip.a; path = "../../../omim-xcode-build/Debug/libminizip.a"; sourceTree = "<group>"; };
 		394917291BAC3CAC002A8C4F /* libsuccinct.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libsuccinct.a; path = "../../../omim-xcode-build/Debug/libsuccinct.a"; sourceTree = "<group>"; };
 		3949172F1BAC3CC9002A8C4F /* libz.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libz.tbd; path = usr/lib/libz.tbd; sourceTree = SDKROOT; };
-		395D1A87207BBA16001164A5 /* pointd_to_pointu.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pointd_to_pointu.cpp; sourceTree = "<group>"; };
-		395D1A88207BBA16001164A5 /* pointd_to_pointu.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = pointd_to_pointu.hpp; sourceTree = "<group>"; };
 		395D1A8B207BBB95001164A5 /* bwt_coder_tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bwt_coder_tests.cpp; sourceTree = "<group>"; };
 		395D1A8D207BBB9E001164A5 /* text_storage_tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = text_storage_tests.cpp; sourceTree = "<group>"; };
-		395D1A8F207BBBA5001164A5 /* pointd_to_pointu_tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pointd_to_pointu_tests.cpp; sourceTree = "<group>"; };
 		395D1A91207BBBAC001164A5 /* zlib_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = zlib_test.cpp; sourceTree = "<group>"; };
 		39B2B97A1FB4692D00AB85A1 /* text_storage.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = text_storage.hpp; sourceTree = "<group>"; };
 		39B2B97C1FB4693400AB85A1 /* bwt_coder.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = bwt_coder.hpp; sourceTree = "<group>"; };
 		39B2B97E1FB4693B00AB85A1 /* elias_coder.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = elias_coder.hpp; sourceTree = "<group>"; };
 		39B2B9801FB4694300AB85A1 /* memory_region.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = memory_region.hpp; sourceTree = "<group>"; };
+		39C3C0BA21A43060003B4712 /* point_coding.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = point_coding.hpp; sourceTree = "<group>"; };
+		39C3C0BB21A43061003B4712 /* point_coding.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = point_coding.cpp; sourceTree = "<group>"; };
+		39C3C0BE21A431BF003B4712 /* point_coding_tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = point_coding_tests.cpp; sourceTree = "<group>"; };
 		39F376C4207D327B0058E8E0 /* geometry_coding.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = geometry_coding.cpp; sourceTree = "<group>"; };
 		39F376C5207D327B0058E8E0 /* geometry_coding.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = geometry_coding.hpp; sourceTree = "<group>"; };
 		39F376C8207D32820058E8E0 /* tesselator_decl.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = tesselator_decl.hpp; sourceTree = "<group>"; };
@@ -215,9 +212,6 @@
 		4563B05E205909280057556D /* serdes_binary_header.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = serdes_binary_header.hpp; sourceTree = "<group>"; };
 		4563B05F205909280057556D /* sha1.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sha1.cpp; sourceTree = "<group>"; };
 		4563B060205909280057556D /* sha1.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = sha1.hpp; sourceTree = "<group>"; };
-		45C108B21E9CFE69000FE1F6 /* point_to_integer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = point_to_integer.cpp; sourceTree = "<group>"; };
-		45C108B31E9CFE69000FE1F6 /* point_to_integer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = point_to_integer.hpp; sourceTree = "<group>"; };
-		45C108B61E9CFE78000FE1F6 /* point_to_integer_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = point_to_integer_test.cpp; sourceTree = "<group>"; };
 		45C108B91E9CFF8E000FE1F6 /* libgeometry.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libgeometry.a; path = "/Users/r.kuznetsov/Dev/Projects/omim/xcode/geometry/../../../omim-build/xcode/Debug/libgeometry.a"; sourceTree = "<absolute>"; };
 		670D04B31B0BA9050013A7AC /* expat_impl.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = expat_impl.h; sourceTree = "<group>"; };
 		670D04B41B0BA9050013A7AC /* file64_api.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = file64_api.hpp; sourceTree = "<group>"; };
@@ -366,11 +360,11 @@
 		394916901BAC3A5F002A8C4F /* coding_tests */ = {
 			isa = PBXGroup;
 			children = (
+				39C3C0BE21A431BF003B4712 /* point_coding_tests.cpp */,
 				39F376CB207D329F0058E8E0 /* geometry_coding_test.cpp */,
 				39F376CC207D329F0058E8E0 /* geometry_serialization_test.cpp */,
 				39F376CA207D329F0058E8E0 /* test_polylines.cpp */,
 				395D1A91207BBBAC001164A5 /* zlib_test.cpp */,
-				395D1A8F207BBBA5001164A5 /* pointd_to_pointu_tests.cpp */,
 				395D1A8D207BBB9E001164A5 /* text_storage_tests.cpp */,
 				395D1A8B207BBB95001164A5 /* bwt_coder_tests.cpp */,
 				67E8DB7A1BBC18720053C5BA /* libs */,
@@ -399,7 +393,6 @@
 				67E8DB1A1BBC16C70053C5BA /* mem_file_writer_test.cpp */,
 				67E8DB1B1BBC16C70053C5BA /* multilang_utf8_string_test.cpp */,
 				67E8DB1C1BBC16C70053C5BA /* png_decoder_test.cpp */,
-				45C108B61E9CFE78000FE1F6 /* point_to_integer_test.cpp */,
 				67E8DB1D1BBC16C70053C5BA /* reader_cache_test.cpp */,
 				67E8DB1E1BBC16C70053C5BA /* reader_test.cpp */,
 				67E8DB1F1BBC16C70053C5BA /* reader_test.hpp */,
@@ -455,11 +448,11 @@
 		6753421D1A3F586300A0A8C3 /* coding */ = {
 			isa = PBXGroup;
 			children = (
+				39C3C0BB21A43061003B4712 /* point_coding.cpp */,
+				39C3C0BA21A43060003B4712 /* point_coding.hpp */,
 				39F376C8207D32820058E8E0 /* tesselator_decl.hpp */,
 				39F376C4207D327B0058E8E0 /* geometry_coding.cpp */,
 				39F376C5207D327B0058E8E0 /* geometry_coding.hpp */,
-				395D1A87207BBA16001164A5 /* pointd_to_pointu.cpp */,
-				395D1A88207BBA16001164A5 /* pointd_to_pointu.hpp */,
 				6753422B1A3F588B00A0A8C3 /* base64.cpp */,
 				6753422C1A3F588B00A0A8C3 /* base64.hpp */,
 				6753422F1A3F588B00A0A8C3 /* bit_streams.hpp */,
@@ -500,8 +493,6 @@
 				6753425A1A3F588B00A0A8C3 /* multilang_utf8_string.cpp */,
 				6753425B1A3F588B00A0A8C3 /* multilang_utf8_string.hpp */,
 				6753425C1A3F588B00A0A8C3 /* parse_xml.hpp */,
-				45C108B21E9CFE69000FE1F6 /* point_to_integer.cpp */,
-				45C108B31E9CFE69000FE1F6 /* point_to_integer.hpp */,
 				6753425D1A3F588B00A0A8C3 /* polymorph_reader.hpp */,
 				6753425E1A3F588B00A0A8C3 /* read_write_utils.hpp */,
 				6753425F1A3F588B00A0A8C3 /* reader_cache.hpp */,
@@ -594,7 +585,6 @@
 				675342961A3F588C00A0A8C3 /* dd_vector.hpp in Headers */,
 				675342C91A3F588C00A0A8C3 /* var_record_reader.hpp in Headers */,
 				675342991A3F588C00A0A8C3 /* endianness.hpp in Headers */,
-				395D1A8A207BBA16001164A5 /* pointd_to_pointu.hpp in Headers */,
 				347F333C1C4540F0009758CC /* succinct_mapper.hpp in Headers */,
 				675342951A3F588C00A0A8C3 /* constants.hpp in Headers */,
 				454523B4202AEB21009275C1 /* serdes_json.hpp in Headers */,
@@ -604,6 +594,7 @@
 				675342B41A3F588C00A0A8C3 /* read_write_utils.hpp in Headers */,
 				675342981A3F588C00A0A8C3 /* diff.hpp in Headers */,
 				670D04C01B0BA92D0013A7AC /* file_data.hpp in Headers */,
+				39C3C0BC21A43061003B4712 /* point_coding.hpp in Headers */,
 				39F376C7207D327B0058E8E0 /* geometry_coding.hpp in Headers */,
 				4563B063205909290057556D /* sha1.hpp in Headers */,
 				6753428B1A3F588C00A0A8C3 /* buffer_reader.hpp in Headers */,
@@ -622,7 +613,6 @@
 				675342A11A3F588C00A0A8C3 /* file_sort.hpp in Headers */,
 				675342971A3F588C00A0A8C3 /* diff_patch_common.hpp in Headers */,
 				675342861A3F588C00A0A8C3 /* bit_streams.hpp in Headers */,
-				45C108B51E9CFE69000FE1F6 /* point_to_integer.hpp in Headers */,
 				675342A01A3F588C00A0A8C3 /* file_reader.hpp in Headers */,
 				675342C71A3F588C00A0A8C3 /* url_encode.hpp in Headers */,
 				675342BC1A3F588C00A0A8C3 /* reader.hpp in Headers */,
@@ -727,9 +717,7 @@
 				39F376D2207D32AA0058E8E0 /* test_polylines.cpp in Sources */,
 				67E8DB671BBC17490053C5BA /* png_decoder_test.cpp in Sources */,
 				394917201BAC3BE0002A8C4F /* testingmain.cpp in Sources */,
-				395D1A96207BBF63001164A5 /* pointd_to_pointu_tests.cpp in Sources */,
 				39F376D3207D32AD0058E8E0 /* geometry_serialization_test.cpp in Sources */,
-				45C108B81E9CFE7B000FE1F6 /* point_to_integer_test.cpp in Sources */,
 				67E8DB5D1BBC17490053C5BA /* endianness_test.cpp in Sources */,
 				3D489BC11D3D21A40052AA38 /* simple_dense_coding_test.cpp in Sources */,
 				67E8DB641BBC17490053C5BA /* mem_file_reader_test.cpp in Sources */,
@@ -740,6 +728,7 @@
 				67E8DB5C1BBC17490053C5BA /* diff_test.cpp in Sources */,
 				67E8DB701BBC17490053C5BA /* value_opt_string_test.cpp in Sources */,
 				67E8DB681BBC17490053C5BA /* reader_cache_test.cpp in Sources */,
+				39C3C0C221A43200003B4712 /* point_coding_tests.cpp in Sources */,
 				67E8DB6F1BBC17490053C5BA /* url_encode_test.cpp in Sources */,
 				67E8DB721BBC17490053C5BA /* var_serial_vector_test.cpp in Sources */,
 				67E8DB5B1BBC17490053C5BA /* dd_vector_test.cpp in Sources */,
@@ -775,7 +764,6 @@
 				4563B062205909290057556D /* sha1.cpp in Sources */,
 				347F33371C4540F0009758CC /* compressed_bit_vector.cpp in Sources */,
 				3D74EF221F8F55740081202C /* csv_reader.cpp in Sources */,
-				395D1A89207BBA16001164A5 /* pointd_to_pointu.cpp in Sources */,
 				6753429F1A3F588C00A0A8C3 /* file_reader.cpp in Sources */,
 				34A129D31DF99E43001B4531 /* zlib.cpp in Sources */,
 				676818201DC3ABD80094C0AC /* traffic_test.cpp in Sources */,
@@ -787,12 +775,12 @@
 				675342A71A3F588C00A0A8C3 /* hex.cpp in Sources */,
 				675342A31A3F588C00A0A8C3 /* file_writer.cpp in Sources */,
 				670D04BF1B0BA92D0013A7AC /* file_data.cpp in Sources */,
+				39C3C0BD21A43061003B4712 /* point_coding.cpp in Sources */,
 				675342CC1A3F588C00A0A8C3 /* varint_vector.cpp in Sources */,
 				675342B91A3F588C00A0A8C3 /* reader_writer_ops.cpp in Sources */,
 				39F376C6207D327B0058E8E0 /* geometry_coding.cpp in Sources */,
 				675E889C1DB7B0D000F8EBDA /* traffic.cpp in Sources */,
 				675342AE1A3F588C00A0A8C3 /* mmap_reader.cpp in Sources */,
-				45C108B41E9CFE69000FE1F6 /* point_to_integer.cpp in Sources */,
 				6753429A1A3F588C00A0A8C3 /* file_container.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;