diff --git a/base/base_tests/string_utils_test.cpp b/base/base_tests/string_utils_test.cpp
index 9d416c287b..7612468777 100644
--- a/base/base_tests/string_utils_test.cpp
+++ b/base/base_tests/string_utils_test.cpp
@@ -3,10 +3,13 @@
 #include "base/string_utils.hpp"
 #include "base/logging.hpp"
 
-#include "std/iomanip.hpp"
-#include "std/fstream.hpp"
 #include "std/bind.hpp"
+#include "std/fstream.hpp"
+#include "std/iomanip.hpp"
+#include "std/map.hpp"
+#include "std/type_traits.hpp"
 #include "std/unordered_map.hpp"
+#include "std/vector.hpp"
 
 
 /// internal function in base
@@ -206,17 +209,17 @@ UNIT_TEST(to_uint)
 
   s = "-2";
   TEST(!strings::to_uint(s, i), ());
-  
+
   s = "0";
   TEST(strings::to_uint(s, i), ());
   TEST_EQUAL(0, i, ());
-  
+
   s = "123456789123456789123456789";
   TEST(!strings::to_uint(s, i), ());
-  
+
   s = "labuda";
   TEST(!strings::to_uint(s, i), ());
-  
+
   s = "AF";
   TEST(strings::to_uint(s, i, 16), ());
   TEST_EQUAL(175, i, ());
@@ -449,6 +452,18 @@ UNIT_TEST(SimpleTokenizer)
   }
 }
 
+UNIT_TEST(Tokenize)
+{
+  {
+    initializer_list<string> expected{"acb", "def", "ghi"};
+    TEST_EQUAL(strings::Tokenize<vector>("acb def ghi", " " /* delims */), vector<string>(expected), ());
+    TEST_EQUAL(strings::Tokenize<set>("acb def ghi", " " /* delims */), set<string>(expected), ());
+  }
+  {
+    static_assert(is_same<vector<string>, decltype(strings::Tokenize("", ""))>::value);
+  }
+}
+
 UNIT_TEST(LastUniChar)
 {
   TEST_EQUAL(strings::LastUniChar(""), 0, ());
diff --git a/base/stl_add.hpp b/base/stl_add.hpp
index 7a1331358c..8ccfdffa53 100644
--- a/base/stl_add.hpp
+++ b/base/stl_add.hpp
@@ -32,7 +32,7 @@ public:
   }
   void operator() (typename ContainerT::value_type const & t) const
   {
-    m_Container.insert(t);
+    m_Container.insert(end(m_Container), t);
   }
 };
 
diff --git a/base/string_utils.hpp b/base/string_utils.hpp
index 561ec20fe1..8d7c37e8a6 100644
--- a/base/string_utils.hpp
+++ b/base/string_utils.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "base/buffer_vector.hpp"
+#include "base/stl_add.hpp"
 
 #include "std/algorithm.hpp"
 #include "std/cstdint.hpp"
@@ -306,6 +307,14 @@ void Tokenize(string const & str, char const * delims, TFunctor && f)
   }
 }
 
+template <template <typename ...> class Collection = vector>
+Collection<string> Tokenize(string const & str, char const * delims)
+{
+  Collection<string> c;
+  Tokenize(str, delims, MakeInsertFunctor(c));
+  return c;
+}
+
 /// Splits a string by the delimiter, keeps empty parts, on an empty string returns an empty vector.
 /// Does not support quoted columns, newlines in columns and escaped quotes.
 void ParseCSVRow(string const & s, char const delimiter, vector<string> & target);
diff --git a/generator/booking_dataset.cpp b/generator/booking_dataset.cpp
index f2f2bb3373..68741bb64f 100644
--- a/generator/booking_dataset.cpp
+++ b/generator/booking_dataset.cpp
@@ -16,7 +16,6 @@
 
 #include "std/fstream.hpp"
 #include "std/iostream.hpp"
-
 #include "std/sstream.hpp"
 
 namespace generator
@@ -65,8 +64,8 @@ BookingDataset::Hotel::Hotel(string const & src)
 ostream & operator<<(ostream & s, BookingDataset::Hotel const & h)
 {
   s << fixed << setprecision(7);
-  return s << "Name: " << h.name << "\t Address: " << h.address << "\t lat: " << h.lat
-           << " lon: " << h.lon;
+  return s << "Id: " << h.id << "\t Name: " << h.name << "\t Address: " << h.address
+           << "\t lat: " << h.lat << " lon: " << h.lon;
 }
 
 BookingDataset::AddressMatcher::AddressMatcher()
@@ -136,28 +135,30 @@ bool BookingDataset::CanBeBooking(FeatureBuilder1 const & fb) const
   return ftypes::IsHotelChecker::Instance()(fb.GetTypes());
 }
 
-BookingDataset::Hotel const & BookingDataset::GetHotel(size_t index) const
+BookingDataset::Hotel const & BookingDataset::GetHotelById(uint32_t const id) const
 {
-  ASSERT_LESS(index, m_hotels.size(), ());
-  return m_hotels[index];
+  auto const it = m_hotels.find(id);
+  CHECK(it != end(m_hotels), ("Got wrong hotel id:", id));
+  return it->second;
 }
 
-BookingDataset::Hotel & BookingDataset::GetHotel(size_t index)
+BookingDataset::Hotel & BookingDataset::GetHotelById(uint32_t const id)
 {
-  ASSERT_LESS(index, m_hotels.size(), ());
-  return m_hotels[index];
+  auto it = m_hotels.find(id);
+  CHECK(it != end(m_hotels), ("Got wrong hotel id:", id));
+  return it->second;
 }
 
-vector<size_t> BookingDataset::GetNearestHotels(ms::LatLon const & latLon, size_t const limit,
-                                                double const maxDistance /* = 0.0 */) const
+vector<uint32_t> BookingDataset::GetNearestHotels(ms::LatLon const & latLon, size_t const limit,
+                                                  double const maxDistance /* = 0.0 */) const
 {
   namespace bgi = boost::geometry::index;
 
-  vector<size_t> indexes;
+  vector<uint32_t> indexes;
   for_each(bgi::qbegin(m_rtree, bgi::nearest(TPoint(latLon.lat, latLon.lon), limit)),
-           bgi::qend(m_rtree), [&](TValue const & v)
+           bgi::qend(m_rtree), [this, &latLon, &indexes, maxDistance](TValue const & v)
            {
-             auto const & hotel = GetHotel(v.second);
+             auto const & hotel = GetHotelById(v.second);
              double const dist = ms::DistanceOnEarth(latLon.lat, latLon.lon, hotel.lat, hotel.lon);
              if (maxDistance != 0.0 && dist > maxDistance /* max distance in meters */)
                return;
@@ -168,11 +169,15 @@ vector<size_t> BookingDataset::GetNearestHotels(ms::LatLon const & latLon, size_
   return indexes;
 }
 
-void BookingDataset::BuildHotel(size_t const hotelIndex,
+void BookingDataset::BuildHotels(function<void(FeatureBuilder1 &)> const & fn) const
+{
+  for (auto const & item : m_hotels)
+    BuildHotel(item.second, fn);
+}
+
+void BookingDataset::BuildHotel(Hotel const & hotel,
                                 function<void(FeatureBuilder1 &)> const & fn) const
 {
-  auto const & hotel = m_hotels[hotelIndex];
-
   FeatureBuilder1 fb;
   FeatureParams params;
 
@@ -274,7 +279,10 @@ void BookingDataset::LoadHotels(istream & src, string const & addressReferencePa
   m_rtree.clear();
 
   for (string line; getline(src, line);)
-    m_hotels.emplace_back(line);
+  {
+    Hotel hotel(line);
+    m_hotels.emplace(hotel.id, hotel);
+  }
 
   if (!addressReferencePath.empty())
   {
@@ -287,8 +295,9 @@ void BookingDataset::LoadHotels(istream & src, string const & addressReferencePa
 
     size_t matchedNum = 0;
     size_t emptyAddr = 0;
-    for (Hotel & hotel : m_hotels)
+    for (auto & item : m_hotels)
     {
+      auto & hotel = item.second;
       addressMatcher(hotel);
 
       if (hotel.address.empty())
@@ -301,12 +310,11 @@ void BookingDataset::LoadHotels(istream & src, string const & addressReferencePa
     platform.SetWritableDirForTests(backupPath);
   }
 
-  size_t counter = 0;
-  for (auto const & hotel : m_hotels)
+  for (auto const & item : m_hotels)
   {
+    auto const & hotel = item.second;
     TBox b(TPoint(hotel.lat, hotel.lon), TPoint(hotel.lat, hotel.lon));
-    m_rtree.insert(make_pair(b, counter));
-    ++counter;
+    m_rtree.insert(make_pair(b, hotel.id));
   }
 }
 
@@ -321,9 +329,9 @@ size_t BookingDataset::MatchWithBooking(FeatureBuilder1 const & fb) const
   auto const bookingIndexes = GetNearestHotels(MercatorBounds::ToLatLon(fb.GetKeyPoint()),
                                                kMaxSelectedElements, kDistanceLimitInMeters);
 
-  for (size_t const j : bookingIndexes)
+  for (uint32_t const j : bookingIndexes)
   {
-    if (booking_scoring::Match(GetHotel(j), fb).IsMatched())
+    if (booking_scoring::Match(GetHotelById(j), fb).IsMatched())
       return j;
   }
 
diff --git a/generator/booking_dataset.hpp b/generator/booking_dataset.hpp
index 9eb13e778f..9be38fd5da 100644
--- a/generator/booking_dataset.hpp
+++ b/generator/booking_dataset.hpp
@@ -11,6 +11,7 @@
 
 #include "std/function.hpp"
 #include "std/limits.hpp"
+#include "std/map.hpp"
 #include "std/string.hpp"
 
 class FeatureBuilder1;
@@ -22,7 +23,7 @@ class BookingDataset
 public:
   static double constexpr kDistanceLimitInMeters = 150;
   static size_t constexpr kMaxSelectedElements = 3;
-  static size_t constexpr kInvalidHotelIndex = numeric_limits<size_t>::max();
+  static auto constexpr kInvalidHotelIndex = numeric_limits<uint32_t>::max();
 
   struct Hotel
   {
@@ -44,6 +45,7 @@ public:
       Counter
     };
 
+    // TODO(mgsergio): Make a separate type for this or an alias.
     uint32_t id = 0;
     double lat = 0.0;
     double lon = 0.0;
@@ -85,24 +87,26 @@ public:
   bool CanBeBooking(FeatureBuilder1 const & fb) const;
 
   inline size_t Size() const { return m_hotels.size(); }
-  Hotel const & GetHotel(size_t index) const;
-  Hotel & GetHotel(size_t index);
-  vector<size_t> GetNearestHotels(ms::LatLon const & latLon, size_t limit,
-                                  double maxDistance = 0.0) const;
+  Hotel const & GetHotelById(uint32_t id) const;
+  Hotel & GetHotelById(uint32_t id);
+  vector<uint32_t> GetNearestHotels(ms::LatLon const & latLon, size_t limit,
+                                    double maxDistance = 0.0) const;
   bool MatchByName(string const & osmName, vector<size_t> const & bookingIndexes) const;
 
-  void BuildHotel(size_t hotelIndex, function<void(FeatureBuilder1 &)> const & fn) const;
+  void BuildHotels(function<void(FeatureBuilder1 &)> const & fn) const;
 
 protected:
-  vector<Hotel> m_hotels;
+  map<uint32_t, Hotel> m_hotels;
 
   using TPoint = boost::geometry::model::point<float, 2, boost::geometry::cs::cartesian>;
   using TBox = boost::geometry::model::box<TPoint>;
-  using TValue = pair<TBox, size_t>;
+  using TValue = pair<TBox, uint32_t>;
 
   // Create the rtree using default constructor.
   boost::geometry::index::rtree<TValue, boost::geometry::index::quadratic<16>> m_rtree;
 
+  void BuildHotel(Hotel const & hotel, function<void(FeatureBuilder1 &)> const & fn) const;
+
   void LoadHotels(istream & path, string const & addressReferencePath);
   /// @return an index of a matched hotel or numeric_limits<size_t>::max() on failure.
   size_t MatchWithBooking(FeatureBuilder1 const & e) const;
diff --git a/generator/booking_quality_check/booking_quality_check.cpp b/generator/booking_quality_check/booking_quality_check.cpp
index f9adf6eef3..99067a8219 100644
--- a/generator/booking_quality_check/booking_quality_check.cpp
+++ b/generator/booking_quality_check/booking_quality_check.cpp
@@ -9,6 +9,10 @@
 
 #include "coding/file_name_utils.hpp"
 
+#include "base/string_utils.hpp"
+
+#include "std/cstdlib.hpp"
+#include "std/cstring.hpp"
 #include "std/fstream.hpp"
 #include "std/iostream.hpp"
 #include "std/numeric.hpp"
@@ -17,9 +21,10 @@
 
 #include "3party/gflags/src/gflags/gflags.h"
 
-DEFINE_string(osm_file_name, "", "Input .o5m file");
-DEFINE_string(booking_data, "", "Path to booking data in .tsv format");
-DEFINE_string(sample_data, "", "Sample output path");
+DEFINE_string(osm, "", "Input .o5m file");
+DEFINE_string(booking, "", "Path to booking data in .tsv format");
+DEFINE_string(factors, "", "Factors output path");
+DEFINE_string(sample, "", "Path so sample file");
 DEFINE_uint64(selection_size, 1000, "Selection size");
 DEFINE_uint64(seed, minstd_rand::default_seed, "Seed for random shuffle");
 
@@ -31,7 +36,8 @@ string PrintBuilder(FeatureBuilder1 const & fb)
 {
   ostringstream s;
 
-  s << "Name: " << fb.GetName(StringUtf8Multilang::kDefaultCode) << '\t';
+  s << "Id: " << DebugPrint(fb.GetMostGenericOsmId()) << '\t'
+    << "Name: " << fb.GetName(StringUtf8Multilang::kDefaultCode) << '\t';
 
   auto const params = fb.GetParams();
   auto const street = params.GetStreet();
@@ -61,19 +67,42 @@ string PrintBuilder(FeatureBuilder1 const & fb)
   return s.str();
 }
 
-struct Emitter : public EmitterBase
+DECLARE_EXCEPTION(ParseError, RootException);
+
+osm::Id ReadDebuggedPrintedOsmId(string const & str)
 {
-  Emitter(feature::GenerateInfo const & info)
-    : m_bookingDataset(info.m_bookingDatafileName)
+  istringstream sstr(str);
+  string type;
+  uint64_t id;
+  sstr >> type >> id;
+
+  if (sstr.fail())
+    MYTHROW(ParseError, ("Can't make osmId from string", str));
+
+  if (type == "relation")
+    return osm::Id::Relation(id);
+  if (type == "way")
+    return osm::Id::Way(id);
+  if (type == "node")
+    return osm::Id::Node(id);
+
+  MYTHROW(ParseError, ("Can't make osmId from string", str));
+}
+
+class Emitter : public EmitterBase
+{
+public:
+  Emitter(BookingDataset const & booking, map<osm::Id, FeatureBuilder1> & features)
+    : m_bookingDataset(booking)
+    , m_features(features)
   {
-    LOG_SHORT(LINFO, (m_bookingDataset.Size(), "hotels are loaded from Booking."));
-    LOG_SHORT(LINFO, ("OSM data:", FLAGS_osm_file_name));
+    LOG_SHORT(LINFO, ("OSM data:", FLAGS_osm));
   }
 
   void operator()(FeatureBuilder1 & fb) override
   {
     if (m_bookingDataset.CanBeBooking(fb))
-      m_features.emplace_back(fb);
+      m_features.emplace(fb.GetMostGenericOsmId(), fb);
   }
 
   void GetNames(vector<string> & names) const override
@@ -84,109 +113,177 @@ struct Emitter : public EmitterBase
   bool Finish() override
   {
     LOG_SHORT(LINFO, ("Num of tourism elements:", m_features.size()));
-    vector<size_t> elementIndexes(m_features.size());
-    iota(elementIndexes.begin(), elementIndexes.end(), 0);
-
-    shuffle(elementIndexes.begin(), elementIndexes.end(), minstd_rand(FLAGS_seed));
-    if (FLAGS_selection_size < elementIndexes.size())
-      elementIndexes.resize(FLAGS_selection_size);
-
-    stringstream outStream;
-
-    for (size_t i : elementIndexes)
-    {
-      auto const & fb = m_features[i];
-      auto const bookingIndexes = m_bookingDataset.GetNearestHotels(
-          MercatorBounds::ToLatLon(fb.GetKeyPoint()),
-          BookingDataset::kMaxSelectedElements,
-          BookingDataset::kDistanceLimitInMeters);
-
-      for (size_t const j : bookingIndexes)
-      {
-        auto const & hotel = m_bookingDataset.GetHotel(j);
-        auto const score = booking_scoring::Match(hotel, fb);
-
-        auto const center = MercatorBounds::ToLatLon(fb.GetKeyPoint());
-        double const distanceMeters = ms::DistanceOnEarth(center.lat, center.lon,
-                                                          hotel.lat, hotel.lon);
-        auto const matched = score.IsMatched();
-
-        outStream << "# ------------------------------------------" << fixed << setprecision(6)
-                  << endl;
-        outStream << (matched ? 'y' : 'n') << " \t" << i << "\t " << j
-                  << "\tdistance: " << distanceMeters
-                  << "\tdistance score: " << score.m_linearNormDistanceScore
-                  << "\tname score: " << score.m_nameSimilarityScore
-                  << "\tresult score: " << score.GetMatchingScore()
-                  << endl;
-        outStream << "# " << PrintBuilder(fb) << endl;
-        outStream << "# " << hotel << endl;
-        outStream << "# URL: https://www.openstreetmap.org/?mlat=" << hotel.lat
-                  << "&mlon=" << hotel.lon << "#map=18/" << hotel.lat << "/" << hotel.lon << endl;
-      }
-      if (!bookingIndexes.empty())
-        outStream << endl << endl;
-    }
-
-    if (FLAGS_sample_data.empty())
-    {
-      cout << outStream.str();
-    }
-    else
-    {
-      ofstream file(FLAGS_sample_data);
-      if (file.is_open())
-      {
-        file << outStream.str();
-      }
-      else
-      {
-        LOG(LERROR, ("Can't output into", FLAGS_sample_data));
-        return false;
-      }
-    }
-
     return true;
   }
 
-  BookingDataset m_bookingDataset;
-  vector<FeatureBuilder1> m_features;
+private:
+  BookingDataset const & m_bookingDataset;
+  map<osm::Id, FeatureBuilder1> & m_features;
 };
 
-unique_ptr<Emitter> GetEmitter(feature::GenerateInfo const & info)
-{
-  LOG_SHORT(LINFO, ("Booking data:", FLAGS_booking_data));
-  return make_unique<Emitter>(info);
-}
-
 feature::GenerateInfo GetGenerateInfo()
 {
   feature::GenerateInfo info;
-  info.m_bookingDatafileName = FLAGS_booking_data;
-  info.m_osmFileName = FLAGS_osm_file_name;
+  info.m_bookingDatafileName = FLAGS_booking;
+  info.m_osmFileName = FLAGS_osm;
   info.SetNodeStorageType("map");
   info.SetOsmFileType("o5m");
 
-  info.m_intermediateDir =  my::GetDirectory(FLAGS_sample_data);
+  info.m_intermediateDir = my::GetDirectory(FLAGS_factors);
 
-  // ...
+  // Set other info params here.
 
   return info;
 }
+
+struct SampleItem
+{
+  enum MatchStatus {Uninitialized, Yes, No};
+
+  SampleItem() = default;
+
+  SampleItem(osm::Id const & osmId, uint32_t const bookingId, MatchStatus const match = Uninitialized)
+   : m_osmId(osmId)
+   , m_bookingId(bookingId)
+   , m_match(match)
+  {
+  }
+
+  osm::Id m_osmId;
+  uint32_t m_bookingId = BookingDataset::kInvalidHotelIndex;
+
+  MatchStatus m_match = Uninitialized;
+};
+
+SampleItem::MatchStatus ReadMatchStatus(string const & str)
+{
+  if (str == "Yes")
+    return SampleItem::Yes;
+
+  if (str == "No")
+    return SampleItem::No;
+
+  if (str == "Uninitialized")
+    return SampleItem::Uninitialized;
+
+  MYTHROW(ParseError, ("Can't make SampleItem::MatchStatus from string:", str));
+}
+
+SampleItem ReadSampleItem(string const & str)
+{
+  SampleItem item;
+
+  auto const parts = strings::Tokenize(str, "\t");
+  CHECK_EQUAL(parts.size(), 3, ("Cant't make SampleItem from string:", str,
+                                "due to wrong number of fields."));
+
+  item.m_osmId = ReadDebuggedPrintedOsmId(parts[0]);
+  if (!strings::to_uint(parts[1], item.m_bookingId))
+    MYTHROW(ParseError, ("Can't make uint32 from string:", parts[1]));
+  item.m_match = ReadMatchStatus(parts[2]);
+
+  return item;
+}
+
+vector<SampleItem> ReadSample(istream & ist)
+{
+  vector<SampleItem> result;
+
+  size_t lineNumber = 1;
+  try
+  {
+    for (string line; getline(ist, line); ++lineNumber)
+    {
+      result.emplace_back(ReadSampleItem(line));
+    }
+  }
+  catch (ParseError const & e)
+  {
+    LOG(LERROR, ("Wrong format: line", lineNumber, e.Msg()));
+    exit(1);
+  }
+
+  return result;
+}
+
+vector<SampleItem> ReadSampleFromFile(string const & name)
+{
+  ifstream ist(name);
+  CHECK(ist.is_open(), ("Can't open file:", name, strerror(errno)));
+  return ReadSample(ist);
+}
+
+void GenerateFactors(BookingDataset const & booking, map<osm::Id, FeatureBuilder1> const & features,
+                     vector<SampleItem> const & sampleItems, ostream & ost)
+{
+  for (auto const & item : sampleItems)
+  {
+    auto const & hotel = booking.GetHotelById(item.m_bookingId);
+    auto const & feature = features.at(item.m_osmId);
+
+    auto const score = booking_scoring::Match(hotel, feature);
+
+    auto const center = MercatorBounds::ToLatLon(feature.GetKeyPoint());
+    double const distanceMeters = ms::DistanceOnEarth(center.lat, center.lon,
+                                                      hotel.lat, hotel.lon);
+    auto const matched = score.IsMatched();
+
+    ost << "# ------------------------------------------" << fixed << setprecision(6)
+        << endl;
+    ost << (matched ? 'y' : 'n') << " \t" << DebugPrint(feature.GetMostGenericOsmId())
+        << "\t " << hotel.id
+        << "\tdistance: " << distanceMeters
+        << "\tdistance score: " << score.m_linearNormDistanceScore
+        << "\tname score: " << score.m_nameSimilarityScore
+        << "\tresult score: " << score.GetMatchingScore()
+        << endl;
+    ost << "# " << PrintBuilder(feature) << endl;
+    ost << "# " << hotel << endl;
+    ost << "# URL: https://www.openstreetmap.org/?mlat=" << hotel.lat
+        << "&mlon=" << hotel.lon << "#map=18/" << hotel.lat << "/" << hotel.lon << endl;
+  }
+}
 }  // namespace
 
 int main(int argc, char * argv[])
 {
-  google::SetUsageMessage(
-      "Takes OSM XML data from stdin and creates"
-      " data and index files in several passes.");
+  google::SetUsageMessage("Calculates factors for given samples.");
+
+  if (argc == 1)
+  {
+    google::ShowUsageWithFlags(argv[0]);
+    exit(0);
+  }
+
   google::ParseCommandLineFlags(&argc, &argv, true);
 
+  CHECK(!FLAGS_sample.empty(), ("Please specify sample path."));
+  CHECK(!FLAGS_osm.empty(), ("Please specify osm path."));
+  CHECK(!FLAGS_booking.empty(), ("Please specify booking path."));
+  CHECK(!FLAGS_factors.empty(), ("Please specify factors path."));
+
   classificator::Load();
 
   auto info = GetGenerateInfo();
   GenerateIntermediateData(info);
-  GenerateFeatures(info, GetEmitter);
+
+  LOG_SHORT(LINFO, ("Booking data:", FLAGS_booking));
+  BookingDataset booking(info.m_bookingDatafileName);
+  LOG_SHORT(LINFO, (booking.Size(), "hotels are loaded from Booking."));
+
+  map<osm::Id, FeatureBuilder1> features;
+  GenerateFeatures(info, [&booking, &features](feature::GenerateInfo const & /* info */)
+  {
+    return make_unique<Emitter>(booking, features);
+  });
+
+  auto const sample = ReadSampleFromFile(FLAGS_sample);
+  LOG(LINFO, ("Sample size is", sample.size()));
+  {
+    ofstream ost(FLAGS_factors);
+    CHECK(ost.is_open(), ("Can't open file", FLAGS_factors, strerror(errno)));
+    GenerateFactors(booking, features, sample, ost);
+  }
 
   return 0;
 }
diff --git a/generator/osm_id.hpp b/generator/osm_id.hpp
index 58a390af16..1b7815401e 100644
--- a/generator/osm_id.hpp
+++ b/generator/osm_id.hpp
@@ -34,5 +34,4 @@ public:
 };
 
 string DebugPrint(osm::Id const & id);
-
 } // namespace osm
diff --git a/generator/osm_source.cpp b/generator/osm_source.cpp
index 2fe3cb9b57..92c1fe77d7 100644
--- a/generator/osm_source.cpp
+++ b/generator/osm_source.cpp
@@ -391,8 +391,7 @@ public:
     DumpSkippedElements();
 
     // Emit all booking objecs to the map.
-    for (size_t hotelIndex = 0; hotelIndex < m_bookingDataset.Size(); ++hotelIndex)
-      m_bookingDataset.BuildHotel(hotelIndex, [this](FeatureBuilder1 & fb) { Emit(fb); });
+    m_bookingDataset.BuildHotels([this](FeatureBuilder1 & fb) { Emit(fb); });
 
     m_places.ForEach([this](Place const & p)
     {