diff --git a/req/include/req_compactor.hpp b/req/include/req_compactor.hpp
index 4c9f3b6..a55183e 100755
--- a/req/include/req_compactor.hpp
+++ b/req/include/req_compactor.hpp
@@ -109,7 +109,7 @@
   T* items_;
 
   bool ensure_enough_sections();
-  size_t compute_compaction_range(uint32_t secs_to_compact) const;
+  std::pair<uint32_t, uint32_t> compute_compaction_range(uint32_t secs_to_compact) const;
   void grow(size_t new_capacity);
   void ensure_space(size_t num);
 
diff --git a/req/include/req_compactor_impl.hpp b/req/include/req_compactor_impl.hpp
index 96db673..067196c 100755
--- a/req/include/req_compactor_impl.hpp
+++ b/req/include/req_compactor_impl.hpp
@@ -169,12 +169,10 @@
 template<typename T, bool H, typename C, typename A>
 void req_compactor<T, H, C, A>::grow(size_t new_capacity) {
   T* new_items = allocator_.allocate(new_capacity);
-  const size_t from = H ? capacity_ - num_items_ : 0;
-  const size_t to = H ? capacity_ : num_items_;
   size_t new_i = H ? new_capacity - num_items_ : 0;
-  for (size_t i = from; i < to; ++i, ++new_i) {
-    new (new_items + new_i) T(std::move(items_[i]));
-    items_[i].~T();
+  for (auto it = begin(); it != end(); ++it, ++new_i) {
+    new (new_items + new_i) T(std::move(*it));
+    (*it).~T();
   }
   allocator_.deallocate(items_, capacity_);
   items_ = new_items;
@@ -237,23 +235,21 @@
 void req_compactor<T, H, C, A>::compact(req_compactor& next) {
   // choose a part of the buffer to compact
   const uint32_t secs_to_compact = std::min(static_cast<uint32_t>(count_trailing_zeros_in_u32(~state_) + 1), static_cast<uint32_t>(num_sections_));
-  const size_t compaction_range = compute_compaction_range(secs_to_compact);
-  const uint32_t compact_from = compaction_range & 0xFFFFFFFFLL; // low 32
-  const uint32_t compact_to = compaction_range >> 32; // high 32
-  if (compact_to - compact_from < 2) throw std::logic_error("compaction range error");
+  auto compaction_range = compute_compaction_range(secs_to_compact);
+  if (compaction_range.second - compaction_range.first < 2) throw std::logic_error("compaction range error");
 
   if ((state_ & 1) == 1) { coin_ = !coin_; } // for odd flip coin;
   else { coin_ = req_random_bit(); } // random coin flip
 
-  const auto num = (compact_to - compact_from) / 2;
+  const auto num = (compaction_range.second - compaction_range.first) / 2;
   next.ensure_space(num);
   auto next_middle = H ? next.begin() : next.end();
   auto next_empty = H ? next.begin() - num : next.end();
-  promote_evens_or_odds(begin() + compact_from, begin() + compact_to, coin_, next_empty);
+  promote_evens_or_odds(begin() + compaction_range.first, begin() + compaction_range.second, coin_, next_empty);
   next.num_items_ += num;
   std::inplace_merge(next.begin(), next_middle, next.end(), C());
-  for (size_t i = compact_from; i < compact_to; ++i) (*(begin() + i)).~T();
-  num_items_ -= compact_to - compact_from;
+  for (size_t i = compaction_range.first; i < compaction_range.second; ++i) (*(begin() + i)).~T();
+  num_items_ -= compaction_range.second - compaction_range.first;
 
   ++state_;
   ensure_enough_sections();
@@ -274,13 +270,13 @@
 }
 
 template<typename T, bool H, typename C, typename A>
-size_t req_compactor<T, H, C, A>::compute_compaction_range(uint32_t secs_to_compact) const {
+std::pair<uint32_t, uint32_t> req_compactor<T, H, C, A>::compute_compaction_range(uint32_t secs_to_compact) const {
   uint32_t non_compact = get_nom_capacity() / 2 + (num_sections_ - secs_to_compact) * section_size_;
   // make compacted region even
   if (((num_items_ - non_compact) & 1) == 1) ++non_compact;
   const size_t low = H ? 0 : non_compact;
   const size_t high = H ? num_items_ - non_compact : num_items_;
-  return (high << 32) + low;
+  return std::pair<uint32_t, uint32_t>(low, high);
 }
 
 template<typename T, bool H, typename C, typename A>