diff --git a/c/common/platform.h b/c/common/platform.h
index 3fd0305..9f303bc 100755
--- a/c/common/platform.h
+++ b/c/common/platform.h
@@ -51,210 +51,6 @@
 
 /* >>> >>> >>> hedley macros */
 
-#define BROTLI_MAKE_VERSION(major, minor, revision) \
-  (((major) * 1000000) + ((minor) * 1000) + (revision))
-
-#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
-#define BROTLI_GNUC_VERSION \
-  BROTLI_MAKE_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
-#elif defined(__GNUC__)
-#define BROTLI_GNUC_VERSION BROTLI_MAKE_VERSION(__GNUC__, __GNUC_MINOR__, 0)
-#endif
-
-#if defined(BROTLI_GNUC_VERSION)
-#define BROTLI_GNUC_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_GNUC_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_GNUC_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
-#define BROTLI_MSVC_VERSION                                \
-  BROTLI_MAKE_VERSION((_MSC_FULL_VER / 10000000),          \
-                      (_MSC_FULL_VER % 10000000) / 100000, \
-                      (_MSC_FULL_VER % 100000) / 100)
-#elif defined(_MSC_FULL_VER)
-#define BROTLI_MSVC_VERSION                              \
-  BROTLI_MAKE_VERSION((_MSC_FULL_VER / 1000000),         \
-                      (_MSC_FULL_VER % 1000000) / 10000, \
-                      (_MSC_FULL_VER % 10000) / 10)
-#elif defined(_MSC_VER)
-#define BROTLI_MSVC_VERSION \
-  BROTLI_MAKE_VERSION(_MSC_VER / 100, _MSC_VER % 100, 0)
-#endif
-
-#if !defined(_MSC_VER)
-#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) (0)
-#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
-#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) \
-  (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
-#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
-#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) \
-  (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
-#else
-#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) \
-  (_MSC_VER >= ((major * 100) + (minor)))
-#endif
-
-#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
-#define BROTLI_INTEL_VERSION                   \
-  BROTLI_MAKE_VERSION(__INTEL_COMPILER / 100,  \
-                      __INTEL_COMPILER % 100,  \
-                      __INTEL_COMPILER_UPDATE)
-#elif defined(__INTEL_COMPILER)
-#define BROTLI_INTEL_VERSION \
-  BROTLI_MAKE_VERSION(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
-#endif
-
-#if defined(BROTLI_INTEL_VERSION)
-#define BROTLI_INTEL_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_INTEL_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_INTEL_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__PGI) && \
-    defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
-#define BROTLI_PGI_VERSION \
-  BROTLI_MAKE_VERSION(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
-#endif
-
-#if defined(BROTLI_PGI_VERSION)
-#define BROTLI_PGI_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_PGI_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_PGI_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
-#define BROTLI_SUNPRO_VERSION                                       \
-  BROTLI_MAKE_VERSION(                                              \
-    (((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), \
-    (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf),   \
-    (__SUNPRO_C & 0xf) * 10)
-#elif defined(__SUNPRO_C)
-#define BROTLI_SUNPRO_VERSION                  \
-  BROTLI_MAKE_VERSION((__SUNPRO_C >> 8) & 0xf, \
-                      (__SUNPRO_C >> 4) & 0xf, \
-                      (__SUNPRO_C) & 0xf)
-#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
-#define BROTLI_SUNPRO_VERSION                                         \
-  BROTLI_MAKE_VERSION(                                                \
-    (((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), \
-    (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf),   \
-    (__SUNPRO_CC & 0xf) * 10)
-#elif defined(__SUNPRO_CC)
-#define BROTLI_SUNPRO_VERSION                   \
-  BROTLI_MAKE_VERSION((__SUNPRO_CC >> 8) & 0xf, \
-                      (__SUNPRO_CC >> 4) & 0xf, \
-                      (__SUNPRO_CC) & 0xf)
-#endif
-
-#if defined(BROTLI_SUNPRO_VERSION)
-#define BROTLI_SUNPRO_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_SUNPRO_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_SUNPRO_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
-#define BROTLI_ARM_VERSION                                       \
-  BROTLI_MAKE_VERSION((__ARMCOMPILER_VERSION / 1000000),         \
-                      (__ARMCOMPILER_VERSION % 1000000) / 10000, \
-                      (__ARMCOMPILER_VERSION % 10000) / 100)
-#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
-#define BROTLI_ARM_VERSION                                 \
-  BROTLI_MAKE_VERSION((__ARMCC_VERSION / 1000000),         \
-                      (__ARMCC_VERSION % 1000000) / 10000, \
-                      (__ARMCC_VERSION % 10000) / 100)
-#endif
-
-#if defined(BROTLI_ARM_VERSION)
-#define BROTLI_ARM_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_ARM_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_ARM_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__ibmxl__)
-#define BROTLI_IBM_VERSION                    \
-  BROTLI_MAKE_VERSION(__ibmxl_version__,      \
-                      __ibmxl_release__,      \
-                      __ibmxl_modification__)
-#elif defined(__xlC__) && defined(__xlC_ver__)
-#define BROTLI_IBM_VERSION \
-  BROTLI_MAKE_VERSION(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
-#elif defined(__xlC__)
-#define BROTLI_IBM_VERSION BROTLI_MAKE_VERSION(__xlC__ >> 8, __xlC__ & 0xff, 0)
-#endif
-
-#if defined(BROTLI_IBM_VERSION)
-#define BROTLI_IBM_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_IBM_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_IBM_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__TI_COMPILER_VERSION__)
-#define BROTLI_TI_VERSION                                         \
-  BROTLI_MAKE_VERSION((__TI_COMPILER_VERSION__ / 1000000),        \
-                      (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
-                      (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(BROTLI_TI_VERSION)
-#define BROTLI_TI_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_TI_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_TI_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__IAR_SYSTEMS_ICC__)
-#if __VER__ > 1000
-#define BROTLI_IAR_VERSION                     \
-  BROTLI_MAKE_VERSION((__VER__ / 1000000),     \
-                      (__VER__ / 1000) % 1000, \
-                      (__VER__ % 1000))
-#else
-#define BROTLI_IAR_VERSION BROTLI_MAKE_VERSION(VER / 100, __VER__ % 100, 0)
-#endif
-#endif
-
-#if defined(BROTLI_IAR_VERSION)
-#define BROTLI_IAR_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_IAR_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_IAR_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__TINYC__)
-#define BROTLI_TINYC_VERSION \
-  BROTLI_MAKE_VERSION(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
-#endif
-
-#if defined(BROTLI_TINYC_VERSION)
-#define BROTLI_TINYC_VERSION_CHECK(major, minor, patch) \
-  (BROTLI_TINYC_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
-#else
-#define BROTLI_TINYC_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(__has_attribute)
-#define BROTLI_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) \
-  __has_attribute(attribute)
-#else
-#define BROTLI_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) \
-  BROTLI_GNUC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(__has_builtin)
-#define BROTLI_GNUC_HAS_BUILTIN(builtin, major, minor, patch) \
-  __has_builtin(builtin)
-#else
-#define BROTLI_GNUC_HAS_BUILTIN(builtin, major, minor, patch) \
-  BROTLI_GNUC_VERSION_CHECK(major, minor, patch)
-#endif
-
 /* Define "BROTLI_PREDICT_TRUE" and "BROTLI_PREDICT_FALSE" macros for capable
    compilers.
 
@@ -375,7 +171,7 @@
 #endif
 #endif
 
-/* <<< <<< <<< end of headley macros. */
+/* <<< <<< <<< end of hedley macros. */
 
 #if BROTLI_GNUC_HAS_ATTRIBUTE(unused, 2, 7, 0) || \
     BROTLI_INTEL_VERSION_CHECK(16, 0, 0)
diff --git a/c/enc/backward_references.c b/c/enc/backward_references.c
index 3dd897b..cd023d9 100644
--- a/c/enc/backward_references.c
+++ b/c/enc/backward_references.c
@@ -97,6 +97,21 @@
 #include "./backward_references_inc.h"
 #undef HASHER
 
+#define HASHER() H35
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
+#define HASHER() H55
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
+#define HASHER() H65
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
 #undef PREFIX
 
 #undef EXPORT_FN
diff --git a/c/enc/hash.h b/c/enc/hash.h
index fc7356b..2602490 100644
--- a/c/enc/hash.h
+++ b/c/enc/hash.h
@@ -153,14 +153,14 @@
     size_t max_length, size_t max_backward, size_t max_distance,
     HasherSearchResult* out) {
   size_t len;
-  size_t dist;
+  size_t word_idx;
   size_t offset;
   size_t matchlen;
   size_t backward;
   score_t score;
   len = item & 0x1F;
-  dist = item >> 5;
-  offset = dictionary->words->offsets_by_length[len] + len * dist;
+  word_idx = item >> 5;
+  offset = dictionary->words->offsets_by_length[len] + len * word_idx;
   if (len > max_length) {
     return BROTLI_FALSE;
   }
@@ -174,7 +174,7 @@
     size_t cut = len - matchlen;
     size_t transform_id = (cut << 2) +
         (size_t)((dictionary->cutoffTransforms >> (cut * 6)) & 0x3F);
-    backward = max_backward + dist + 1 +
+    backward = max_backward + 1 + word_idx +
         (transform_id << dictionary->words->size_bits_by_length[len]);
   }
   if (backward > max_distance) {
@@ -343,11 +343,57 @@
 #undef BUCKET_BITS
 #undef HASHER
 
+/* fast large window hashers */
+
+#define HASHER() HROLLING_FAST
+#define CHUNKLEN 32
+#define JUMP 4
+#define NUMBUCKETS 16777216
+#define MASK ((NUMBUCKETS * 64) - 1)
+#include "./hash_rolling_inc.h"  /* NOLINT(build/include) */
+#undef JUMP
+#undef HASHER
+
+
+#define HASHER() HROLLING
+#define JUMP 1
+#include "./hash_rolling_inc.h"  /* NOLINT(build/include) */
+#undef MASK
+#undef NUMBUCKETS
+#undef JUMP
+#undef CHUNKLEN
+#undef HASHER
+
+#define HASHER() H35
+#define HASHER_A H3
+#define HASHER_B HROLLING_FAST
+#include "./hash_composite_inc.h"  /* NOLINT(build/include) */
+#undef HASHER_A
+#undef HASHER_B
+#undef HASHER
+
+#define HASHER() H55
+#define HASHER_A H54
+#define HASHER_B HROLLING_FAST
+#include "./hash_composite_inc.h"  /* NOLINT(build/include) */
+#undef HASHER_A
+#undef HASHER_B
+#undef HASHER
+
+#define HASHER() H65
+#define HASHER_A H6
+#define HASHER_B HROLLING
+#include "./hash_composite_inc.h"  /* NOLINT(build/include) */
+#undef HASHER_A
+#undef HASHER_B
+#undef HASHER
+
 #undef FN
 #undef CAT
 #undef EXPAND_CAT
 
-#define FOR_GENERIC_HASHERS(H) H(2) H(3) H(4) H(5) H(6) H(40) H(41) H(42) H(54)
+#define FOR_GENERIC_HASHERS(H) H(2) H(3) H(4) H(5) H(6) H(40) H(41) H(42) H(54)\
+                               H(35) H(55) H(65)
 #define FOR_ALL_HASHERS(H) FOR_GENERIC_HASHERS(H) H(10)
 
 static BROTLI_INLINE void DestroyHasher(
diff --git a/c/enc/hash_composite_inc.h b/c/enc/hash_composite_inc.h
new file mode 100755
index 0000000..f829a97
--- /dev/null
+++ b/c/enc/hash_composite_inc.h
@@ -0,0 +1,133 @@
+/* NOLINT(build/header_guard) */
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+/* template parameters: FN, HASHER_A, HASHER_B */
+
+/* Composite hasher: This hasher allows to combine two other hashers, HASHER_A
+   and HASHER_B. */
+
+#define HashComposite HASHER()
+
+#define FN_A(X) EXPAND_CAT(X, HASHER_A)
+#define FN_B(X) EXPAND_CAT(X, HASHER_B)
+
+static BROTLI_INLINE size_t FN(HashTypeLength)(void) {
+  size_t a =  FN_A(HashTypeLength)();
+  size_t b =  FN_B(HashTypeLength)();
+  return a > b ? a : b;
+}
+
+static BROTLI_INLINE size_t FN(StoreLookahead)(void) {
+  size_t a =  FN_A(StoreLookahead)();
+  size_t b =  FN_B(StoreLookahead)();
+  return a > b ? a : b;
+}
+
+typedef struct HashComposite {
+  HasherHandle ha;
+  HasherHandle hb;
+  const BrotliEncoderParams* params;
+} HashComposite;
+
+static BROTLI_INLINE HashComposite* FN(Self)(HasherHandle handle) {
+  return (HashComposite*)&(GetHasherCommon(handle)[1]);
+}
+
+static void FN(Initialize)(
+    HasherHandle handle, const BrotliEncoderParams* params) {
+  HashComposite* self = FN(Self)(handle);
+  self->ha = 0;
+  self->hb = 0;
+  self->params = params;
+  /* TODO: Initialize of the hashers is defered to Prepare (and params
+     remembered here) because we don't get the one_shot and input_size params
+     here that are needed to know the memory size of them. Instead provide
+     those params to all hashers FN(Initialize) */
+}
+
+static void FN(Prepare)(HasherHandle handle, BROTLI_BOOL one_shot,
+    size_t input_size, const uint8_t* data) {
+  HashComposite* self = FN(Self)(handle);
+  if (!self->ha) {
+    HasherCommon* common_a;
+    HasherCommon* common_b;
+
+    self->ha = handle + sizeof(HasherCommon) + sizeof(HashComposite);
+    common_a = (HasherCommon*)self->ha;
+    common_a->params = self->params->hasher;
+    common_a->is_prepared_ = BROTLI_FALSE;
+    common_a->dict_num_lookups = 0;
+    common_a->dict_num_matches = 0;
+    FN_A(Initialize)(self->ha, self->params);
+
+    self->hb = self->ha + sizeof(HasherCommon) + FN_A(HashMemAllocInBytes)(
+        self->params, one_shot, input_size);
+    common_b = (HasherCommon*)self->hb;
+    common_b->params = self->params->hasher;
+    common_b->is_prepared_ = BROTLI_FALSE;
+    common_b->dict_num_lookups = 0;
+    common_b->dict_num_matches = 0;
+    FN_B(Initialize)(self->hb, self->params);
+  }
+  FN_A(Prepare)(self->ha, one_shot, input_size, data);
+  FN_B(Prepare)(self->hb, one_shot, input_size, data);
+}
+
+static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
+    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
+    size_t input_size) {
+  return sizeof(HashComposite) + 2 * sizeof(HasherCommon) +
+      FN_A(HashMemAllocInBytes)(params, one_shot, input_size) +
+      FN_B(HashMemAllocInBytes)(params, one_shot, input_size);
+}
+
+static BROTLI_INLINE void FN(Store)(HasherHandle BROTLI_RESTRICT handle,
+    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
+  HashComposite* self = FN(Self)(handle);
+  FN_A(Store)(self->ha, data, mask, ix);
+  FN_B(Store)(self->hb, data, mask, ix);
+}
+
+static BROTLI_INLINE void FN(StoreRange)(HasherHandle handle,
+    const uint8_t* data, const size_t mask, const size_t ix_start,
+    const size_t ix_end) {
+  HashComposite* self = FN(Self)(handle);
+  FN_A(StoreRange)(self->ha, data, mask, ix_start, ix_end);
+  FN_B(StoreRange)(self->hb, data, mask, ix_start, ix_end);
+}
+
+static BROTLI_INLINE void FN(StitchToPreviousBlock)(HasherHandle handle,
+    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
+    size_t ring_buffer_mask) {
+  HashComposite* self = FN(Self)(handle);
+  FN_A(StitchToPreviousBlock)(self->ha, num_bytes, position, ringbuffer,
+      ring_buffer_mask);
+  FN_B(StitchToPreviousBlock)(self->hb, num_bytes, position, ringbuffer,
+      ring_buffer_mask);
+}
+
+static BROTLI_INLINE void FN(PrepareDistanceCache)(
+    HasherHandle handle, int* BROTLI_RESTRICT distance_cache) {
+  HashComposite* self = FN(Self)(handle);
+  FN_A(PrepareDistanceCache)(self->ha, distance_cache);
+  FN_B(PrepareDistanceCache)(self->hb, distance_cache);
+}
+
+static BROTLI_INLINE void FN(FindLongestMatch)(HasherHandle handle,
+    const BrotliEncoderDictionary* dictionary,
+    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
+    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
+    const size_t max_length, const size_t max_backward, const size_t gap,
+    const size_t max_distance, HasherSearchResult* BROTLI_RESTRICT out) {
+  HashComposite* self = FN(Self)(handle);
+  FN_A(FindLongestMatch)(self->ha, dictionary, data, ring_buffer_mask,
+      distance_cache, cur_ix, max_length, max_backward, gap, max_distance, out);
+  FN_B(FindLongestMatch)(self->hb, dictionary, data, ring_buffer_mask,
+      distance_cache, cur_ix, max_length, max_backward, gap, max_distance, out);
+}
+
+#undef HashComposite
diff --git a/c/enc/hash_rolling_inc.h b/c/enc/hash_rolling_inc.h
new file mode 100755
index 0000000..4d5d14a
--- /dev/null
+++ b/c/enc/hash_rolling_inc.h
@@ -0,0 +1,215 @@
+/* NOLINT(build/header_guard) */
+/* Copyright 2018 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+/* template parameters: FN, JUMP, NUMBUCKETS, MASK, CHUNKLEN */
+/* NUMBUCKETS / (MASK + 1) = probability of storing and using hash code. */
+/* JUMP = skip bytes for speedup */
+
+/* Rolling hash for long distance long string matches. Stores one position
+   per bucket, bucket key is computed over a long region. */
+
+#define HashRolling HASHER()
+
+static const uint32_t FN(kRollingHashMul32) = 69069;
+static const uint32_t FN(kInvalidPos) = 0xffffffff;
+
+/* This hasher uses a longer forward length, but returning a higher value here
+   will hurt compression by the main hasher when combined with a composite
+   hasher. The hasher tests for forward itself instead. */
+static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
+static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
+
+/* Computes a code from a single byte. A lookup table of 256 values could be
+   used, but simply adding 1 works about as good. */
+static uint32_t FN(HashByte)(uint8_t byte) {
+  return (uint32_t)byte + 1u;
+}
+
+static uint32_t FN(HashRollingFunctionInitial)(uint32_t state, uint8_t add,
+                                               uint32_t factor) {
+  return (uint32_t)(factor * state + FN(HashByte)(add));
+}
+
+static uint32_t FN(HashRollingFunction)(uint32_t state, uint8_t add,
+                                        uint8_t rem, uint32_t factor,
+                                        uint32_t factor_remove) {
+  return (uint32_t)(factor * state +
+      FN(HashByte)(add) - factor_remove * FN(HashByte)(rem));
+}
+
+typedef struct HashRolling {
+  uint32_t state;
+  uint32_t* table;
+  size_t next_ix;
+
+  uint32_t chunk_len;
+  uint32_t factor;
+  uint32_t factor_remove;
+} HashRolling;
+
+static BROTLI_INLINE HashRolling* FN(Self)(HasherHandle handle) {
+  return (HashRolling*)&(GetHasherCommon(handle)[1]);
+}
+
+static void FN(Initialize)(
+    HasherHandle handle, const BrotliEncoderParams* params) {
+  HashRolling* self = FN(Self)(handle);
+  size_t i;
+  self->state = 0;
+  self->next_ix = 0;
+
+  self->factor = FN(kRollingHashMul32);
+
+  /* Compute the factor of the oldest byte to remove: factor**steps modulo
+     0xffffffff (the multiplications rely on 32-bit overflow) */
+  self->factor_remove = 1;
+  for (i = 0; i < CHUNKLEN; i += JUMP) {
+    self->factor_remove *= self->factor;
+  }
+
+  self->table = (uint32_t*)((HasherHandle)self + sizeof(HashRolling));
+  for (i = 0; i < NUMBUCKETS; i++) {
+    self->table[i] = FN(kInvalidPos);
+  }
+
+  BROTLI_UNUSED(params);
+}
+
+static void FN(Prepare)(HasherHandle handle, BROTLI_BOOL one_shot,
+    size_t input_size, const uint8_t* data) {
+  HashRolling* self = FN(Self)(handle);
+  size_t i;
+  /* Too small size, cannot use this hasher. */
+  if (input_size < CHUNKLEN) return;
+  self->state = 0;
+  for (i = 0; i < CHUNKLEN; i += JUMP) {
+    self->state = FN(HashRollingFunctionInitial)(
+        self->state, data[i], self->factor);
+  }
+  BROTLI_UNUSED(one_shot);
+}
+
+static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
+    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
+    size_t input_size) {
+  return sizeof(HashRolling) + NUMBUCKETS * sizeof(uint32_t);
+  BROTLI_UNUSED(params);
+  BROTLI_UNUSED(one_shot);
+  BROTLI_UNUSED(input_size);
+}
+
+static BROTLI_INLINE void FN(Store)(HasherHandle BROTLI_RESTRICT handle,
+    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
+  BROTLI_UNUSED(handle);
+  BROTLI_UNUSED(data);
+  BROTLI_UNUSED(mask);
+  BROTLI_UNUSED(ix);
+}
+
+static BROTLI_INLINE void FN(StoreRange)(HasherHandle handle,
+    const uint8_t* data, const size_t mask, const size_t ix_start,
+    const size_t ix_end) {
+  BROTLI_UNUSED(handle);
+  BROTLI_UNUSED(data);
+  BROTLI_UNUSED(mask);
+  BROTLI_UNUSED(ix_start);
+  BROTLI_UNUSED(ix_end);
+}
+
+static BROTLI_INLINE void FN(StitchToPreviousBlock)(HasherHandle handle,
+    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
+    size_t ring_buffer_mask) {
+  /* In this case we must re-initialize the hasher from scratch from the
+     current position. */
+  HashRolling* self = FN(Self)(handle);
+  size_t position_masked;
+  size_t available = num_bytes;
+  if ((position & (JUMP - 1)) != 0) {
+    size_t diff = JUMP - (position & (JUMP - 1));
+    available = (diff > available) ? 0 : (available - diff);
+    position += diff;
+  }
+  position_masked = position & ring_buffer_mask;
+  /* wrapping around ringbuffer not handled. */
+  if (available > ring_buffer_mask - position_masked) {
+    available = ring_buffer_mask - position_masked;
+  }
+
+  FN(Prepare)(handle, BROTLI_FALSE, available,
+      ringbuffer + (position & ring_buffer_mask));
+  self->next_ix = position;
+  BROTLI_UNUSED(num_bytes);
+}
+
+static BROTLI_INLINE void FN(PrepareDistanceCache)(
+    HasherHandle handle, int* BROTLI_RESTRICT distance_cache) {
+  BROTLI_UNUSED(handle);
+  BROTLI_UNUSED(distance_cache);
+}
+
+static BROTLI_INLINE void FN(FindLongestMatch)(HasherHandle handle,
+    const BrotliEncoderDictionary* dictionary,
+    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
+    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
+    const size_t max_length, const size_t max_backward, const size_t gap,
+    const size_t max_distance, HasherSearchResult* BROTLI_RESTRICT out) {
+  HashRolling* self = FN(Self)(handle);
+  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
+  size_t pos = self->next_ix;
+
+  if ((cur_ix & (JUMP - 1)) != 0) return;
+
+  /* Not enough lookahead */
+  if (max_length < CHUNKLEN) return;
+
+  for (pos = self->next_ix; pos <= cur_ix; pos += JUMP) {
+    uint32_t code = self->state & MASK;
+
+    uint8_t rem = data[pos & ring_buffer_mask];
+    uint8_t add = data[(pos + CHUNKLEN) & ring_buffer_mask];
+    size_t found_ix = FN(kInvalidPos);
+
+    self->state = FN(HashRollingFunction)(
+        self->state, add, rem, self->factor, self->factor_remove);
+
+    if (code < NUMBUCKETS) {
+      found_ix = self->table[code];
+      self->table[code] = (uint32_t)pos;
+      if (pos == cur_ix && found_ix != FN(kInvalidPos)) {
+        /* The cast to 32-bit makes backward distances up to 4GB work even
+           if cur_ix is above 4GB, despite using 32-bit values in the table. */
+        size_t backward = (uint32_t)(cur_ix - found_ix);
+        if (backward <= max_backward) {
+          const size_t found_ix_masked = found_ix & ring_buffer_mask;
+          const size_t len = FindMatchLengthWithLimit(&data[found_ix_masked],
+                                                      &data[cur_ix_masked],
+                                                      max_length);
+          if (len >= 4 && len > out->len) {
+            score_t score = BackwardReferenceScore(len, backward);
+            if (score > out->score) {
+              out->len = len;
+              out->distance = backward;
+              out->score = score;
+              out->len_code_delta = 0;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  self->next_ix = cur_ix + JUMP;
+
+  /* NOTE: this hasher does not search in the dictionary. It is used as
+     backup-hasher, the main hasher already searches in it. */
+  BROTLI_UNUSED(dictionary);
+  BROTLI_UNUSED(distance_cache);
+  BROTLI_UNUSED(gap);
+  BROTLI_UNUSED(max_distance);
+}
+
+#undef HashRolling
diff --git a/c/enc/quality.h b/c/enc/quality.h
index aa7ba0d..5f4d034 100644
--- a/c/enc/quality.h
+++ b/c/enc/quality.h
@@ -142,6 +142,24 @@
     hparams->num_last_distances_to_check =
         params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
   }
+
+  if (params->lgwin > 24) {
+    /* Different hashers for large window brotli: not for qualities <= 2,
+       these are too fast for large window. Not for qualities >= 10: their
+       hasher already works well with large window. So the changes are:
+       H3 --> H35: for quality 3.
+       H54 --> H55: for quality 4 with size hint > 1MB
+       H6 --> H65: for qualities 5, 6, 7, 8, 9. */
+    if (hparams->type == 3) {
+      hparams->type = 35;
+    }
+    if (hparams->type == 54) {
+      hparams->type = 55;
+    }
+    if (hparams->type == 6) {
+      hparams->type = 65;
+    }
+  }
 }
 
 #endif  /* BROTLI_ENC_QUALITY_H_ */
diff --git a/c/include/brotli/port.h b/c/include/brotli/port.h
index e5ac4ba..20dc231 100644
--- a/c/include/brotli/port.h
+++ b/c/include/brotli/port.h
@@ -9,7 +9,230 @@
 #ifndef BROTLI_COMMON_PORT_H_
 #define BROTLI_COMMON_PORT_H_
 
-/* NB: borrowed from github.com.nemequ/hedley. */
+/* The following macros were borrowed from https://github.com/nemequ/hedley
+ * with permission of original author - Evan Nemerson <evan@nemerson.com> */
+
+/* >>> >>> >>> hedley macros */
+
+#define BROTLI_MAKE_VERSION(major, minor, revision) \
+  (((major) * 1000000) + ((minor) * 1000) + (revision))
+
+#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
+#define BROTLI_GNUC_VERSION \
+  BROTLI_MAKE_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#elif defined(__GNUC__)
+#define BROTLI_GNUC_VERSION BROTLI_MAKE_VERSION(__GNUC__, __GNUC_MINOR__, 0)
+#endif
+
+#if defined(BROTLI_GNUC_VERSION)
+#define BROTLI_GNUC_VERSION_CHECK(major, minor, patch) \
+  (BROTLI_GNUC_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
+#else
+#define BROTLI_GNUC_VERSION_CHECK(major, minor, patch) (0)
+#endif
+
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
+#define BROTLI_MSVC_VERSION                                \
+  BROTLI_MAKE_VERSION((_MSC_FULL_VER / 10000000),          \
+                      (_MSC_FULL_VER % 10000000) / 100000, \
+                      (_MSC_FULL_VER % 100000) / 100)
+#elif defined(_MSC_FULL_VER)
+#define BROTLI_MSVC_VERSION                              \
+  BROTLI_MAKE_VERSION((_MSC_FULL_VER / 1000000),         \
+                      (_MSC_FULL_VER % 1000000) / 10000, \
+                      (_MSC_FULL_VER % 10000) / 10)
+#elif defined(_MSC_VER)
+#define BROTLI_MSVC_VERSION \
+  BROTLI_MAKE_VERSION(_MSC_VER / 100, _MSC_VER % 100, 0)
+#endif
+
+#if !defined(_MSC_VER)
+#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) (0)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) \
+  (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
+#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) \
+  (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
+#else
+#define BROTLI_MSVC_VERSION_CHECK(major, minor, patch) \
+  (_MSC_VER >= ((major * 100) + (minor)))
+#endif
+
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
+#define BROTLI_INTEL_VERSION                   \
+  BROTLI_MAKE_VERSION(__INTEL_COMPILER / 100,  \
+                      __INTEL_COMPILER % 100,  \
+                      __INTEL_COMPILER_UPDATE)
+#elif defined(__INTEL_COMPILER)
+#define BROTLI_INTEL_VERSION \
+  BROTLI_MAKE_VERSION(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
+#endif
+
+#if defined(BROTLI_INTEL_VERSION)
+#define BROTLI_INTEL_VERSION_CHECK(major, minor, patch) \
+  (BROTLI_INTEL_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
+#else
+#define BROTLI_INTEL_VERSION_CHECK(major, minor, patch) (0)
+#endif
+
+#if defined(__PGI) && \
+    defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
+#define BROTLI_PGI_VERSION \
+  BROTLI_MAKE_VERSION(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
+#endif
+
+#if defined(BROTLI_PGI_VERSION)
+#define BROTLI_PGI_VERSION_CHECK(major, minor, patch) \
+  (BROTLI_PGI_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
+#else
+#define BROTLI_PGI_VERSION_CHECK(major, minor, patch) (0)
+#endif
+
+#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
+#define BROTLI_SUNPRO_VERSION                                       \
+  BROTLI_MAKE_VERSION(                                              \
+    (((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), \
+    (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf),   \
+    (__SUNPRO_C & 0xf) * 10)
+#elif defined(__SUNPRO_C)
+#define BROTLI_SUNPRO_VERSION                  \
+  BROTLI_MAKE_VERSION((__SUNPRO_C >> 8) & 0xf, \
+                      (__SUNPRO_C >> 4) & 0xf, \
+                      (__SUNPRO_C) & 0xf)
+#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
+#define BROTLI_SUNPRO_VERSION                                         \
+  BROTLI_MAKE_VERSION(                                                \
+    (((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), \
+    (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf),   \
+    (__SUNPRO_CC & 0xf) * 10)
+#elif defined(__SUNPRO_CC)
+#define BROTLI_SUNPRO_VERSION                   \
+  BROTLI_MAKE_VERSION((__SUNPRO_CC >> 8) & 0xf, \
+                      (__SUNPRO_CC >> 4) & 0xf, \
+                      (__SUNPRO_CC) & 0xf)
+#endif
+
+#if defined(BROTLI_SUNPRO_VERSION)
+#define BROTLI_SUNPRO_VERSION_CHECK(major, minor, patch) \
+  (BROTLI_SUNPRO_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
+#else
+#define BROTLI_SUNPRO_VERSION_CHECK(major, minor, patch) (0)
+#endif
+
+#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
+#define BROTLI_ARM_VERSION                                       \
+  BROTLI_MAKE_VERSION((__ARMCOMPILER_VERSION / 1000000),         \
+                      (__ARMCOMPILER_VERSION % 1000000) / 10000, \
+                      (__ARMCOMPILER_VERSION % 10000) / 100)
+#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
+#define BROTLI_ARM_VERSION                                 \
+  BROTLI_MAKE_VERSION((__ARMCC_VERSION / 1000000),         \
+                      (__ARMCC_VERSION % 1000000) / 10000, \
+                      (__ARMCC_VERSION % 10000) / 100)
+#endif
+
+#if defined(BROTLI_ARM_VERSION)
+#define BROTLI_ARM_VERSION_CHECK(major, minor, patch) \
+  (BROTLI_ARM_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
+#else
+#define BROTLI_ARM_VERSION_CHECK(major, minor, patch) (0)
+#endif
+
+#if defined(__ibmxl__)
+#define BROTLI_IBM_VERSION                    \
+  BROTLI_MAKE_VERSION(__ibmxl_version__,      \
+                      __ibmxl_release__,      \
+                      __ibmxl_modification__)
+#elif defined(__xlC__) && defined(__xlC_ver__)
+#define BROTLI_IBM_VERSION \
+  BROTLI_MAKE_VERSION(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
+#elif defined(__xlC__)
+#define BROTLI_IBM_VERSION BROTLI_MAKE_VERSION(__xlC__ >> 8, __xlC__ & 0xff, 0)
+#endif
+
+#if defined(BROTLI_IBM_VERSION)
+#define BROTLI_IBM_VERSION_CHECK(major, minor, patch) \
+  (BROTLI_IBM_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
+#else
+#define BROTLI_IBM_VERSION_CHECK(major, minor, patch) (0)
+#endif
+
+#if defined(__TI_COMPILER_VERSION__)
+#define BROTLI_TI_VERSION                                         \
+  BROTLI_MAKE_VERSION((__TI_COMPILER_VERSION__ / 1000000),        \
+                      (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
+                      (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(BROTLI_TI_VERSION)
+#define BROTLI_TI_VERSION_CHECK(major, minor, patch) \
+  (BROTLI_TI_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
+#else
+#define BROTLI_TI_VERSION_CHECK(major, minor, patch) (0)
+#endif
+
+#if defined(__IAR_SYSTEMS_ICC__)
+#if __VER__ > 1000
+#define BROTLI_IAR_VERSION                     \
+  BROTLI_MAKE_VERSION((__VER__ / 1000000),     \
+                      (__VER__ / 1000) % 1000, \
+                      (__VER__ % 1000))
+#else
+#define BROTLI_IAR_VERSION BROTLI_MAKE_VERSION(VER / 100, __VER__ % 100, 0)
+#endif
+#endif
+
+#if defined(BROTLI_IAR_VERSION)
+#define BROTLI_IAR_VERSION_CHECK(major, minor, patch) \
+  (BROTLI_IAR_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
+#else
+#define BROTLI_IAR_VERSION_CHECK(major, minor, patch) (0)
+#endif
+
+#if defined(__TINYC__)
+#define BROTLI_TINYC_VERSION \
+  BROTLI_MAKE_VERSION(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
+#endif
+
+#if defined(BROTLI_TINYC_VERSION)
+#define BROTLI_TINYC_VERSION_CHECK(major, minor, patch) \
+  (BROTLI_TINYC_VERSION >= BROTLI_MAKE_VERSION(major, minor, patch))
+#else
+#define BROTLI_TINYC_VERSION_CHECK(major, minor, patch) (0)
+#endif
+
+#if defined(__has_attribute)
+#define BROTLI_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) \
+  __has_attribute(attribute)
+#else
+#define BROTLI_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) \
+  BROTLI_GNUC_VERSION_CHECK(major, minor, patch)
+#endif
+
+#if defined(__has_builtin)
+#define BROTLI_GNUC_HAS_BUILTIN(builtin, major, minor, patch) \
+  __has_builtin(builtin)
+#else
+#define BROTLI_GNUC_HAS_BUILTIN(builtin, major, minor, patch) \
+  BROTLI_GNUC_VERSION_CHECK(major, minor, patch)
+#endif
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define BROTLI_PUBLIC
+#elif BROTLI_GNUC_VERSION_CHECK(3, 3, 0) ||                         \
+    BROTLI_TI_VERSION_CHECK(8, 0, 0) ||                             \
+    BROTLI_INTEL_VERSION_CHECK(16, 0, 0) ||                         \
+    BROTLI_ARM_VERSION_CHECK(4, 1, 0) ||                            \
+    BROTLI_IBM_VERSION_CHECK(13, 1, 0) ||                           \
+    BROTLI_SUNPRO_VERSION_CHECK(5, 11, 0) ||                        \
+    (BROTLI_TI_VERSION_CHECK(7, 3, 0) &&                            \
+     defined(__TI_GNU_ATTRIBUTE_SUPPORT__) && defined(__TI_EABI__))
+#define BROTLI_PUBLIC __attribute__ ((visibility ("default")))
+#else
+#define BROTLI_PUBLIC
+#endif
+
 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
     !defined(__STDC_NO_VLA__) && !defined(__cplusplus) &&         \
     !defined(__PGI) && !defined(__PGIC__) && !defined(__TINYC__)
@@ -18,7 +241,10 @@
 #define BROTLI_ARRAY_PARAM(name)
 #endif
 
-#if defined(BROTLI_SHARED_COMPILATION) && defined(_WIN32)
+/* <<< <<< <<< end of hedley macros. */
+
+#if defined(BROTLI_SHARED_COMPILATION)
+#if defined(_WIN32)
 #if defined(BROTLICOMMON_SHARED_COMPILATION)
 #define BROTLI_COMMON_API __declspec(dllexport)
 #else
@@ -34,7 +260,12 @@
 #else
 #define BROTLI_ENC_API __declspec(dllimport)
 #endif  /* BROTLIENC_SHARED_COMPILATION */
-#else  /* BROTLI_SHARED_COMPILATION && _WIN32 */
+#else  /* _WIN32 */
+#define BROTLI_COMMON_API BROTLI_PUBLIC
+#define BROTLI_DEC_API BROTLI_PUBLIC
+#define BROTLI_ENC_API BROTLI_PUBLIC
+#endif  /* _WIN32 */
+#else  /* BROTLI_SHARED_COMPILATION */
 #define BROTLI_COMMON_API
 #define BROTLI_DEC_API
 #define BROTLI_ENC_API