diff --git a/3party/bsdiff-courgette/CMakeLists.txt b/3party/bsdiff-courgette/CMakeLists.txt
index d2e13fb5f1..2ee83de38c 100644
--- a/3party/bsdiff-courgette/CMakeLists.txt
+++ b/3party/bsdiff-courgette/CMakeLists.txt
@@ -1,7 +1,5 @@
 project(bsdiff)
 
-set(CMAKE_PREFIX_PATH ./)
-
 add_clang_compile_options("-Wno-shorten-64-to-32")
 
 include_directories(bsdiff divsufsort)
diff --git a/3party/bsdiff-courgette/bsdiff/bsdiff.h b/3party/bsdiff-courgette/bsdiff/bsdiff.h
index eecdf2f059..9a0c0a255a 100644
--- a/3party/bsdiff-courgette/bsdiff/bsdiff.h
+++ b/3party/bsdiff-courgette/bsdiff/bsdiff.h
@@ -34,6 +34,10 @@
 //                --Stephen Adams <sra@chromium.org>
 // 2013-04-10 - Added wrapper to apply a patch directly to files.
 //                --Joshua Pawlicki <waffles@chromium.org>
+// 2017-08-14 - Moved "apply" and "create" to the header file, rewrote
+//              all routines to use MAPS.ME readers and writers instead
+//              of Courgette streams and files.
+//                --Maxim Pimenov <m@maps.me>
 
 // Changelog for bsdiff_apply:
 // 2009-03-31 - Change to use Streams.  Move CRC code to crc.{h,cc}
@@ -123,6 +127,7 @@ BSDiffStatus CreateBinaryPatch(OldReader & old_reader,
 
   my::Timer bsdiff_timer;
 
+  CHECK_GREATER_OR_EQUAL(kNumStreams, 6, ());
   std::array<MemStream, kNumStreams> mem_streams;
   auto & control_stream_copy_counts = mem_streams[0];
   auto & control_stream_extra_counts = mem_streams[1];
@@ -405,6 +410,7 @@ BSDiffStatus ApplyBinaryPatch(OldReader & old_reader,
   if (CalculateCrc(old_start, old_size) != header.scrc32)
     return CRC_ERROR;
 
+  CHECK_GREATER_OR_EQUAL(kNumStreams, 6, ());
   vector<uint32_t> stream_sizes(kNumStreams);
   for (auto & s : stream_sizes)
     s = ReadPrimitiveFromSource<uint32_t>(patch_source);
diff --git a/generator/mwm_diff/diff.cpp b/generator/mwm_diff/diff.cpp
index 68276122a1..ca9ecc8bdc 100644
--- a/generator/mwm_diff/diff.cpp
+++ b/generator/mwm_diff/diff.cpp
@@ -19,8 +19,63 @@ using namespace std;
 
 namespace
 {
-// Format Version 0: bsdiff+gzip.
-uint32_t const kLatestVersion = 0;
+enum Version
+{
+  // Format Version 0: bsdiff+gzip.
+  VERSION_V0 = 0,
+  VERSION_LATEST = VERSION_V0
+};
+
+bool MakeDiffVersion0(FileReader & oldReader, FileReader & newReader, FileWriter & diffFileWriter)
+{
+  vector<uint8_t> diffBuf;
+  MemWriter<vector<uint8_t>> diffMemWriter(diffBuf);
+
+  auto const status = bsdiff::CreateBinaryPatch(oldReader, newReader, diffMemWriter);
+
+  if (status != bsdiff::BSDiffStatus::OK)
+  {
+    LOG(LERROR, ("Could not create patch with bsdiff:", status));
+    return false;
+  }
+
+  using Deflate = coding::ZLib::Deflate;
+  Deflate deflate(Deflate::Format::ZLib, Deflate::Level::BestCompression);
+
+  vector<uint8_t> deflatedDiffBuf;
+  deflate(diffBuf.data(), diffBuf.size(), back_inserter(deflatedDiffBuf));
+
+  // A basic header that holds only version.
+  WriteToSink(diffFileWriter, static_cast<uint32_t>(VERSION_V0));
+  diffFileWriter.Write(deflatedDiffBuf.data(), deflatedDiffBuf.size());
+
+  return true;
+}
+
+bool ApplyDiffVersion0(FileReader & oldReader, FileWriter & newWriter,
+                       ReaderSource<FileReader> & diffFileSource)
+{
+  vector<uint8_t> deflatedDiff(diffFileSource.Size());
+  diffFileSource.Read(deflatedDiff.data(), deflatedDiff.size());
+
+  using Inflate = coding::ZLib::Inflate;
+  vector<uint8_t> decompressedData;
+  Inflate inflate(Inflate::Format::ZLib);
+  vector<uint8_t> diffBuf;
+  inflate(deflatedDiff.data(), deflatedDiff.size(), back_inserter(diffBuf));
+
+  MemReader diffMemReader(diffBuf.data(), diffBuf.size());
+
+  auto status = bsdiff::ApplyBinaryPatch(oldReader, newWriter, diffMemReader);
+
+  if (status != bsdiff::BSDiffStatus::OK)
+  {
+    LOG(LERROR, ("Could not apply patch with bsdiff:", status));
+    return false;
+  }
+
+  return true;
+}
 }  // namespace
 
 namespace generator
@@ -35,26 +90,13 @@ bool MakeDiff(string const & oldMwmPath, string const & newMwmPath, string const
     FileReader newReader(newMwmPath);
     FileWriter diffFileWriter(diffPath);
 
-    vector<uint8_t> diffBuf;
-    MemWriter<vector<uint8_t>> diffMemWriter(diffBuf);
-
-    auto const status = bsdiff::CreateBinaryPatch(oldReader, newReader, diffMemWriter);
-
-    if (status != bsdiff::BSDiffStatus::OK)
+    switch (VERSION_LATEST)
     {
-      LOG(LERROR, ("Could not create patch with bsdiff:", status));
-      return false;
+    case VERSION_V0: return MakeDiffVersion0(oldReader, newReader, diffFileWriter);
+    default:
+      LOG(LERROR,
+          ("Making mwm diffs with diff format version", VERSION_LATEST, "is not implemented"));
     }
-
-    using Deflate = coding::ZLib::Deflate;
-    Deflate deflate(Deflate::Format::ZLib, Deflate::Level::BestCompression);
-
-    vector<uint8_t> deflatedDiffBuf;
-    deflate(diffBuf.data(), diffBuf.size(), back_inserter(deflatedDiffBuf));
-
-    uint32_t const header = kLatestVersion;
-    WriteToSink(diffFileWriter, header);
-    diffFileWriter.Write(deflatedDiffBuf.data(), deflatedDiffBuf.size());
   }
   catch (Reader::Exception const & e)
   {
@@ -67,7 +109,7 @@ bool MakeDiff(string const & oldMwmPath, string const & newMwmPath, string const
     return false;
   }
 
-  return true;
+  return false;
 }
 
 bool ApplyDiff(string const & oldMwmPath, string const & newMwmPath, string const & diffPath)
@@ -79,30 +121,12 @@ bool ApplyDiff(string const & oldMwmPath, string const & newMwmPath, string cons
     FileReader diffFileReader(diffPath);
 
     ReaderSource<FileReader> diffFileSource(diffFileReader);
-    auto const header = ReadPrimitiveFromSource<uint32_t>(diffFileSource);
-    if (header != kLatestVersion)
+    auto const version = ReadPrimitiveFromSource<uint32_t>(diffFileSource);
+
+    switch (version)
     {
-      LOG(LERROR, ("Unknown version format of mwm diff:", header));
-      return false;
-    }
-
-    vector<uint8_t> deflatedDiff(diffFileSource.Size());
-    diffFileSource.Read(deflatedDiff.data(), deflatedDiff.size());
-
-    using Inflate = coding::ZLib::Inflate;
-    vector<uint8_t> decompressedData;
-    Inflate inflate(Inflate::Format::ZLib);
-    vector<uint8_t> diffBuf;
-    inflate(deflatedDiff.data(), deflatedDiff.size(), back_inserter(diffBuf));
-
-    MemReader diffMemReader(diffBuf.data(), diffBuf.size());
-
-    auto status = bsdiff::ApplyBinaryPatch(oldReader, newWriter, diffMemReader);
-
-    if (status != bsdiff::BSDiffStatus::OK)
-    {
-      LOG(LERROR, ("Could not apply patch with bsdiff:", status));
-      return false;
+    case VERSION_V0: return ApplyDiffVersion0(oldReader, newWriter, diffFileSource);
+    default: LOG(LERROR, ("Unknown version format of mwm diff:", version));
     }
   }
   catch (Reader::Exception const & e)
@@ -116,7 +140,7 @@ bool ApplyDiff(string const & oldMwmPath, string const & newMwmPath, string cons
     return false;
   }
 
-  return true;
+  return false;
 }
 }  // namespace mwm_diff
 }  // namespace generator