diff --git a/base/cache.hpp b/base/cache.hpp
index e82ed2cb38..0003c2cc27 100644
--- a/base/cache.hpp
+++ b/base/cache.hpp
@@ -78,14 +78,13 @@ namespace my
       return Hash(uint32_t(x) ^ uint32_t(x >> 32));
     }
 
-#pragma pack(push, 1)
+    // TODO: Consider using separate arrays for keys and values, to save on padding.
     struct Data
     {
       Data() : m_Key(), m_Value() {}
       KeyT m_Key;
       ValueT m_Value;
     };
-#pragma pack(pop)
 
     Data * const m_Cache;
     uint32_t const m_HashMask;
diff --git a/geometry/cellid.hpp b/geometry/cellid.hpp
index ec6e0627b5..d58412d1cd 100644
--- a/geometry/cellid.hpp
+++ b/geometry/cellid.hpp
@@ -9,7 +9,6 @@
 namespace m2
 {
 
-#pragma pack(push, 1)
 template <int kDepthLevels> class CellId
 {
 public:
@@ -251,7 +250,6 @@ private:
   int64_t m_Bits;
   int m_Level;
 };
-#pragma pack(pop)
 
 template <int DEPTH_LEVELS> string debug_print(CellId<DEPTH_LEVELS> const & id)
 {
diff --git a/indexer/indexer_tests/interval_index_test.cpp b/indexer/indexer_tests/interval_index_test.cpp
index ad841bf157..3f5c2bb184 100644
--- a/indexer/indexer_tests/interval_index_test.cpp
+++ b/indexer/indexer_tests/interval_index_test.cpp
@@ -8,12 +8,24 @@
 #include "../../std/utility.hpp"
 #include "../../std/vector.hpp"
 
+namespace
+{
+struct CellIdFeaturePairForTest
+{
+  CellIdFeaturePairForTest(uint64_t cell, uint32_t feature) : m_Cell(cell), m_Feature(feature) {}
+  uint64_t GetCell() const { return m_Cell; }
+  uint32_t GetFeature() const { return m_Feature; }
+  uint64_t m_Cell;
+  uint32_t m_Feature;
+};
+}
+
 UNIT_TEST(IntervalIndex_Simple)
 {
-  vector<pair<int64_t, uint32_t> > data;
-  data.push_back(make_pair(0xA0B1C2D100ULL, 0));
-  data.push_back(make_pair(0xA0B1C2D200ULL, 1));
-  data.push_back(make_pair(0xA0B2C2D100ULL, 2));
+  vector<CellIdFeaturePairForTest> data;
+  data.push_back(CellIdFeaturePairForTest(0xA0B1C2D100ULL, 0));
+  data.push_back(CellIdFeaturePairForTest(0xA0B1C2D200ULL, 1));
+  data.push_back(CellIdFeaturePairForTest(0xA0B2C2D100ULL, 2));
   vector<char> serializedIndex;
   MemWriter<vector<char> > writer(serializedIndex);
   BuildIntervalIndex<5>(data.begin(), data.end(), writer, 2);
@@ -63,7 +75,7 @@ UNIT_TEST(IntervalIndex_Simple)
 
 UNIT_TEST(IntervalIndex_Empty)
 {
-  vector<pair<int64_t, uint32_t> > data;
+  vector<CellIdFeaturePairForTest> data;
   vector<char> serializedIndex;
   MemWriter<vector<char> > writer(serializedIndex);
   BuildIntervalIndex<5>(data.begin(), data.end(), writer, 2);
@@ -78,11 +90,11 @@ UNIT_TEST(IntervalIndex_Empty)
 
 UNIT_TEST(IntervalIndex_Simple2)
 {
-  vector<pair<int64_t, uint32_t> > data;
-  data.push_back(make_pair(0xA0B1C2D200ULL, 0));
-  data.push_back(make_pair(0xA0B1C2D200ULL, 1));
-  data.push_back(make_pair(0xA0B1C2D200ULL, 3));
-  data.push_back(make_pair(0xA0B2C2D200ULL, 2));
+  vector<CellIdFeaturePairForTest> data;
+  data.push_back(CellIdFeaturePairForTest(0xA0B1C2D200ULL, 0));
+  data.push_back(CellIdFeaturePairForTest(0xA0B1C2D200ULL, 1));
+  data.push_back(CellIdFeaturePairForTest(0xA0B1C2D200ULL, 3));
+  data.push_back(CellIdFeaturePairForTest(0xA0B2C2D200ULL, 2));
   vector<char> serializedIndex;
   MemWriter<vector<char> > writer(serializedIndex);
   BuildIntervalIndex<5>(data.begin(), data.end(), writer, 2);
@@ -99,9 +111,9 @@ UNIT_TEST(IntervalIndex_Simple2)
 
 UNIT_TEST(IntervalIndex_Simple3)
 {
-  vector<pair<uint64_t, uint32_t> > data;
-  data.push_back(make_pair(0x0100ULL, 0));
-  data.push_back(make_pair(0x0200ULL, 1));
+  vector<CellIdFeaturePairForTest> data;
+  data.push_back(CellIdFeaturePairForTest(0x0100ULL, 0));
+  data.push_back(CellIdFeaturePairForTest(0x0200ULL, 1));
   vector<char> serializedIndex;
   MemWriter<vector<char> > writer(serializedIndex);
   BuildIntervalIndex<2>(data.begin(), data.end(), writer, 1);
@@ -118,9 +130,9 @@ UNIT_TEST(IntervalIndex_Simple3)
 
 UNIT_TEST(IntervalIndex_Simple4)
 {
-  vector<pair<uint64_t, uint32_t> > data;
-  data.push_back(make_pair(0x01030400ULL, 0));
-  data.push_back(make_pair(0x02030400ULL, 1));
+  vector<CellIdFeaturePairForTest> data;
+  data.push_back(CellIdFeaturePairForTest(0x01030400ULL, 0));
+  data.push_back(CellIdFeaturePairForTest(0x02030400ULL, 1));
   vector<char> serializedIndex;
   MemWriter<vector<char> > writer(serializedIndex);
   BuildIntervalIndex<4>(data.begin(), data.end(), writer, 1);
@@ -137,11 +149,11 @@ UNIT_TEST(IntervalIndex_Simple4)
 
 UNIT_TEST(IntervalIndex_Simple5)
 {
-  vector<pair<uint64_t, uint32_t> > data;
-  data.push_back(make_pair(0xA0B1C2D200ULL, 0));
-  data.push_back(make_pair(0xA0B1C2D200ULL, 1));
-  data.push_back(make_pair(0xA0B1C2D200ULL, 3));
-  data.push_back(make_pair(0xA0B2C2D200ULL, 2));
+  vector<CellIdFeaturePairForTest> data;
+  data.push_back(CellIdFeaturePairForTest(0xA0B1C2D200ULL, 0));
+  data.push_back(CellIdFeaturePairForTest(0xA0B1C2D200ULL, 1));
+  data.push_back(CellIdFeaturePairForTest(0xA0B1C2D200ULL, 3));
+  data.push_back(CellIdFeaturePairForTest(0xA0B2C2D200ULL, 2));
   vector<char> serializedIndex;
   MemWriter<vector<char> > writer(serializedIndex);
   BuildIntervalIndex<5>(data.begin(), data.end(), writer, 1);
diff --git a/indexer/indexer_tool/data_cache_file.hpp b/indexer/indexer_tool/data_cache_file.hpp
index 791ae4e5c1..54a71fdb36 100644
--- a/indexer/indexer_tool/data_cache_file.hpp
+++ b/indexer/indexer_tool/data_cache_file.hpp
@@ -193,26 +193,36 @@ namespace cache
     }
   };
 
-#pragma pack(push, 1)
-  struct MappedWay
+  class MappedWay
   {
-    uint64_t m_id;
-    int m_type;
+  public:
 
-    MappedWay() {}
-    MappedWay(uint64_t id, int type) : m_id(id), m_type(type) {}
+    enum WayType
+    {
+      coast_direct = 0,
+      empty_direct = 1,
+      coast_opposite = 2,
+      empty_opposite = 3
+    };
+
+    MappedWay() : m_id(0) {}
+    MappedWay(uint64_t id, WayType type) : m_id((id << 2) | type)
+    {
+      CHECK_EQUAL(0, id & 0xC000000000000000ULL, ("Highest 2 bits should be 0.", id));
+    }
 
     bool operator<(MappedWay const & r) const
     {
-      return ((m_id == r.m_id) ? m_type < r.m_type : m_id < r.m_id);
+      return m_id < r.m_id;
     }
 
-    enum {  coast_direct = 0,
-            empty_direct = 1,
-            coast_opposite = 2,
-            empty_opposite = 3 };
+    uint64_t GetId() const { return m_id >> 2; }
+    WayType GetType() const { return static_cast<WayType>(m_id & 3); }
+
+  private:
+    uint64_t m_id;
   };
-#pragma pack(pop)
+  STATIC_ASSERT(sizeof(MappedWay) == 8);
 
   template <class TNodesHolder, class TData, class TFile>
   class BaseFileHolder
diff --git a/indexer/indexer_tool/data_generator.cpp b/indexer/indexer_tool/data_generator.cpp
index cf600bfd3d..aaf7a37281 100644
--- a/indexer/indexer_tool/data_generator.cpp
+++ b/indexer/indexer_tool/data_generator.cpp
@@ -54,10 +54,11 @@ public:
   {
     typedef cache::MappedWay way_t;
 
-    int const type = (emptyTags ? way_t::empty_direct : way_t::coast_direct);
+    way_t::WayType const directType = (emptyTags ? way_t::empty_direct : way_t::coast_direct);
+    way_t::WayType const oppositeType = (emptyTags ? way_t::empty_opposite : way_t::coast_opposite);
 
-    this->m_mappedWays.write(e.nodes.front(),  way_t(id, type));     // direct
-    this->m_mappedWays.write(e.nodes.back(), way_t(id, type + 2));   // opposite
+    this->m_mappedWays.write(e.nodes.front(),  way_t(id, directType));  // direct
+    this->m_mappedWays.write(e.nodes.back(), way_t(id, oppositeType));  // opposite
   }
 
   void SaveIndex()
diff --git a/indexer/indexer_tool/feature_generator.cpp b/indexer/indexer_tool/feature_generator.cpp
index 143474f65a..4d5b1db53c 100644
--- a/indexer/indexer_tool/feature_generator.cpp
+++ b/indexer/indexer_tool/feature_generator.cpp
@@ -96,10 +96,10 @@ public:
     for (; range.first != range.second; ++range.first)
     {
       cache::MappedWay const & w = range.first->second;
-      if (w.m_type != cache::MappedWay::coast_opposite && w.m_id != prevWay)
+      if (w.GetType() != cache::MappedWay::coast_opposite && w.GetId() != prevWay)
       {
-        this->m_ways.Read(w.m_id, e);
-        prevWay = w.m_id;
+        this->m_ways.Read(w.GetId(), e);
+        prevWay = w.GetId();
         return true;
       }
     }
diff --git a/indexer/interval_index.hpp b/indexer/interval_index.hpp
index e23e6e5b48..851aedf34a 100644
--- a/indexer/interval_index.hpp
+++ b/indexer/interval_index.hpp
@@ -1,7 +1,8 @@
 #pragma once
 #include "../coding/endianness.hpp"
-#include "../base/base.hpp"
 #include "../base/assert.hpp"
+#include "../base/base.hpp"
+#include "../base/macros.hpp"
 
 class IntervalIndexBase
 {
@@ -11,15 +12,28 @@ public:
   {
     uint8_t m_CellIdLeafBytes;
   };
+#pragma pack(pop)
 
-  struct Index
+  class Index
   {
-    uint32_t m_BaseOffset;
+  public:
+    uint32_t GetBaseOffset() const { return UINT32_FROM_UINT16(m_BaseOffsetHi, m_BaseOffsetLo); }
+    void SetBaseOffset(uint32_t baseOffset)
+    {
+      m_BaseOffsetLo = UINT32_LO(baseOffset);
+      m_BaseOffsetHi = UINT32_HI(baseOffset);
+    }
+
+  private:
+    uint16_t m_BaseOffsetLo;
+    uint16_t m_BaseOffsetHi;
+  public:
     uint16_t m_Count[256];
   };
-#pragma pack(pop)
+  STATIC_ASSERT(sizeof(Index) == 2 * 258);
 };
 
+// TODO: IntervalIndex shouldn't do SwapIfBigEndian for ValueT.
 template <typename ValueT, class ReaderT>
 class IntervalIndex : public IntervalIndexBase
 {
@@ -61,7 +75,7 @@ private:
         if (level > m_Header.m_CellIdLeafBytes)
         {
           Index index1;
-          ReadIndex(index.m_BaseOffset + (cumCount * sizeof(Index)), index1);
+          ReadIndex(index.GetBaseOffset() + (cumCount * sizeof(Index)), index1);
           ForEachImpl(f, b1, e1, index1, level - 1);
         }
         else
@@ -69,20 +83,21 @@ private:
           // TODO: Use binary search here if count is very large.
           uint32_t const step = sizeof(ValueT) + m_Header.m_CellIdLeafBytes;
           uint32_t const count = index.m_Count[i];
-          uint32_t pos = index.m_BaseOffset + (cumCount * step);
+          uint32_t pos = index.GetBaseOffset() + (cumCount * step);
           vector<char> data(step * count);
           char const * pData = &data[0];
           m_Reader.Read(pos, &data[0], data.size());
           for (uint32_t j = 0; j < count; ++j, pData += step)
           // for (uint32_t j = 0; j < count; ++j, pos += step)
           {
-            Value value;
-            value.m_CellId = 0;
-            memcpy(&value, pData, step);
+            ValueT value;
+            uint32_t cellIdOnDisk = 0;
+            memcpy(&value, pData, sizeof(ValueT));
+            memcpy(&cellIdOnDisk, pData + sizeof(ValueT), m_Header.m_CellIdLeafBytes);
             // m_Reader.Read(pos, &value, step);
-            uint32_t const cellId = SwapIfBigEndian(value.m_CellId);
+            uint32_t const cellId = SwapIfBigEndian(cellIdOnDisk);
             if (b1 <= cellId && cellId <= e1)
-              f(SwapIfBigEndian(value.m_Value));
+              f(SwapIfBigEndian(value));
           }
         }
         cumCount += index.m_Count[i];
@@ -95,20 +110,11 @@ private:
     m_Reader.Read(pos, &index, sizeof(Index));
     if (IsBigEndian())
     {
-      index.m_BaseOffset = SwapIfBigEndian(index.m_BaseOffset);
       for (uint32_t i = 0; i < 256; ++i)
         index.m_Count[i] = SwapIfBigEndian(index.m_Count[i]);
     }
   }
 
-#pragma pack(push, 1)
-  struct Value
-  {
-    ValueT m_Value;
-    uint32_t m_CellId;
-  };
-#pragma pack(pop)
-
   ReaderT m_Reader;
   Header m_Header;
   Index m_Level0Index;
diff --git a/indexer/interval_index_builder.hpp b/indexer/interval_index_builder.hpp
index 41df0d93fa..8706a91e58 100644
--- a/indexer/interval_index_builder.hpp
+++ b/indexer/interval_index_builder.hpp
@@ -8,6 +8,7 @@
 #include "../std/vector.hpp"
 #include "../std/memcpy.hpp"
 
+// TODO: BuildIntervalIndex() shouldn't rely on indexing cellid-feature pairs.
 template <int kCellIdBytes, typename CellIdValueIterT, class SinkT>
 void BuildIntervalIndex(CellIdValueIterT const & beg, CellIdValueIterT const & end,
                         SinkT & writer, int const leafBytes = 1)
@@ -70,13 +71,13 @@ void BuildIntervalIndex(CellIdValueIterT const & beg, CellIdValueIterT const & e
     uint8_t prevByte = 0;
     for (CellIdValueIterT it = beg; it != end; ++it)
     {
-      uint64_t id = it->first;
+      uint64_t id = it->GetCell();
       uint64_t const thisParentBytes = id >> 8 * (level + 1);
       uint8_t const thisByte = static_cast<uint8_t>(0xFF & (id >> 8 * level));
       if (it != beg && prevParentBytes != thisParentBytes)
       {
         // Writing index for previous parent.
-        index.m_BaseOffset = SwapIfBigEndian(childOffset);
+        index.SetBaseOffset(childOffset);
         for (uint32_t i = 0; i < 256; ++i)
           index.m_Count[i] = SwapIfBigEndian(index.m_Count[i]);
         writer.Write(&index, sizeof(index));
@@ -84,7 +85,7 @@ void BuildIntervalIndex(CellIdValueIterT const & beg, CellIdValueIterT const & e
         if (level != leafBytes)
           childOffset += childCount * sizeof(index);
         else
-          childOffset += (sizeof(beg->second) + leafBytes) * childCount;
+          childOffset += (sizeof(beg->GetFeature()) + leafBytes) * childCount;
         childCount = 0;
         --thisLevelCount;
       }
@@ -95,15 +96,15 @@ void BuildIntervalIndex(CellIdValueIterT const & beg, CellIdValueIterT const & e
         ++childCount;
         ++totalChildCount;
         ++index.m_Count[thisByte];
-        CHECK_LESS(
-            index.m_Count[thisByte], 65535,
-            (level, leafBytes, prevByte, thisByte, prevParentBytes, thisParentBytes, it->first));
+        CHECK_LESS(index.m_Count[thisByte], 65535, (level, leafBytes, prevByte, thisByte, \
+                                                    prevParentBytes, thisParentBytes, \
+                                                    it->GetCell()));
       }
 
       prevParentBytes = thisParentBytes;
       prevByte = thisByte;
     }
-    index.m_BaseOffset = SwapIfBigEndian(childOffset);
+    index.SetBaseOffset(childOffset);
     for (uint32_t i = 0; i < 256; ++i)
       index.m_Count[i] = SwapIfBigEndian(index.m_Count[i]);
     writer.Write(&index, sizeof(index));
@@ -127,8 +128,8 @@ void BuildIntervalIndex(CellIdValueIterT const & beg, CellIdValueIterT const & e
   uint32_t const mask = (1ULL << 8 * leafBytes) - 1;
   for (CellIdValueIterT it = beg; it != end; ++it)
   {
-    WriteToSink(writer, it->second);
-    uint32_t cellId = static_cast<uint32_t>(it->first & mask);
+    WriteToSink(writer, it->GetFeature());
+    uint32_t cellId = static_cast<uint32_t>(it->GetCell() & mask);
     cellId = SwapIfBigEndian(cellId);
     writer.Write(&cellId, leafBytes);
   }
diff --git a/indexer/osm_decl.hpp b/indexer/osm_decl.hpp
index 31cc24efa4..b81364db8a 100644
--- a/indexer/osm_decl.hpp
+++ b/indexer/osm_decl.hpp
@@ -10,12 +10,12 @@
 /// Used to store all world nodes inside temporary index file.
 /// To find node by id, just calculate offset inside index file:
 /// offset_in_file = sizeof(LatLon) * node_ID
-#pragma pack (push, 1)
 struct LatLon
 {
   double lat;
   double lon;
 };
+STATIC_ASSERT(sizeof(LatLon) == 16);
 
 struct LatLonPos
 {
@@ -23,8 +23,7 @@ struct LatLonPos
   double lat;
   double lon;
 };
-#pragma pack (pop)
-
+STATIC_ASSERT(sizeof(LatLonPos) == 24);
 
 #define NODES_FILE "nodes.dat"
 #define WAYS_FILE "ways.dat"
@@ -38,7 +37,7 @@ namespace feature
 {
   /// @name Need to unite features.
   //@{
-  /// @param[in]  k, v  Key and Value from relation tags. 
+  /// @param[in]  k, v  Key and Value from relation tags.
   bool NeedUnite(string const & k, string const & v);
   /// @param[in]  type  Type from feature.
   bool NeedUnite(uint32_t type);
diff --git a/indexer/scale_index_builder.hpp b/indexer/scale_index_builder.hpp
index 3be990b440..8d755fc077 100644
--- a/indexer/scale_index_builder.hpp
+++ b/indexer/scale_index_builder.hpp
@@ -14,30 +14,37 @@
 
 #include "../base/base.hpp"
 #include "../base/logging.hpp"
+#include "../base/macros.hpp"
 
 #include "../std/string.hpp"
 #include "../std/vector.hpp"
 #include "../std/utility.hpp"
 
+class CellFeaturePair
+{
+public:
+  CellFeaturePair() {}
+  CellFeaturePair(uint64_t cell, uint32_t feature)
+    : m_CellLo(UINT64_LO(cell)), m_CellHi(UINT64_HI(cell)), m_Feature(feature) {}
 
-#pragma pack(push, 1)
-  struct CellFeaturePair
+  bool operator< (CellFeaturePair const & rhs) const
   {
-    int64_t first;
-    uint32_t second;
+    if (m_CellHi != rhs.m_CellHi)
+      return m_CellHi < rhs.m_CellHi;
+    if (m_CellLo != rhs.m_CellLo)
+      return m_CellLo < rhs.m_CellLo;
+    return m_Feature < rhs.m_Feature;
+  }
 
-    CellFeaturePair() {}
-    CellFeaturePair(pair<int64_t, uint32_t> const & p) : first(p.first), second(p.second) {}
-    CellFeaturePair(int64_t f, uint32_t s) : first(f), second(s) {}
+  uint64_t GetCell() const { return UINT64_FROM_UINT32(m_CellHi, m_CellLo); }
+  uint32_t GetFeature() const { return m_Feature; }
 
-    bool operator< (CellFeaturePair const & rhs) const
-    {
-      if (first == rhs.first)
-        return (second < rhs.second);
-      return (first < rhs.first);
-    }
-  };
-#pragma pack (pop)
+private:
+  uint32_t m_CellLo;
+  uint32_t m_CellHi;
+  uint32_t m_Feature;
+};
+STATIC_ASSERT(sizeof(CellFeaturePair) == 12);
 
 template <class SorterT>
 class FeatureCoverer
@@ -59,7 +66,7 @@ public:
     {
       vector<int64_t> const cells = covering::CoverFeature(f, m_ScaleRange.second);
       for (vector<int64_t>::const_iterator it = cells.begin(); it != cells.end(); ++it)
-        m_Sorter.Add(make_pair(*it, offset));
+        m_Sorter.Add(CellFeaturePair(*it, offset));
       ++m_NumFeatures;
       return;
     }
@@ -113,7 +120,7 @@ public:
 
   void operator () (CellFeaturePair const & cellFeaturePair)
   {
-    m_Optimizer.Add(cellFeaturePair.first, cellFeaturePair.second);
+    m_Optimizer.Add(cellFeaturePair.GetCell(), cellFeaturePair.GetFeature());
   }
 
 private: